#!/usr/bin/env node import React, { useState, useEffect, useCallback, useRef } from "react"; import { Box, Text, render, useApp, useInput, useStdout, measureElement } from "ink"; import type { DOMElement } from "ink"; import TextInput from "ink-text-input"; import meow from "meow"; import { spawn } from "node:child_process"; import { Readable, Writable } from "node:stream"; import { readFileSync } from "node:fs"; import { dirname, join } from "node:path"; import { fileURLToPath } from "node:url"; import type { SessionNotification, RequestPermissionRequest, RequestPermissionResponse, ToolCallContent, ToolCallStatus, ToolKind, Stream, } from "@agentclientprotocol/sdk"; import { ndJsonStream } from "@agentclientprotocol/sdk"; import { GooseClient } from "@block/goose-acp"; import { renderMarkdown } from "./markdown.js"; import { buildToolCallCardLines, ToolCallCompact, findFeaturedToolCallId } from "./toolcall.js"; import type { ToolCallInfo } from "./toolcall.js"; import { CRANBERRY, TEAL, GOLD, TEXT_PRIMARY, TEXT_SECONDARY, TEXT_DIM, RULE_COLOR } from "./colors.js"; interface PendingPermission { toolTitle: string; options: Array<{ optionId: string; name: string; kind: string }>; resolve: (response: RequestPermissionResponse) => void; } interface Turn { userText: string; toolCalls: Map; toolCallOrder: string[]; agentText: string; } function isErrorStatus(status: string): boolean { return status.startsWith("error") || status.startsWith("failed"); } const GOOSE_FRAMES = [ [ " ,_", " (o >", " //\\", " \\\\ \\", " \\\\_/", " | |", " ^ ^", ], [ " ,_", " (o >", " //\\", " \\\\ \\", " \\\\_/", " / |", " ^ ^", ], [ " ,_", " (o >", " //\\", " \\\\ \\", " \\\\_/", " | |", " ^ ^", ], [ " ,_", " (o >", " //\\", " \\\\ \\", " \\\\_/", " | \\", " ^ ^", ], ]; const GREETING_MESSAGES = [ "What would you like to work on?", "Ready to build something amazing?", "What would you like to explore?", "What's on your mind?", "What shall we create today?", "What project needs attention?", "What would you like to tackle?", "What needs to be done?", "What's the plan for today?", "Ready to create something great?", "What can be built today?", "What's the next challenge?", "What progress can be made?", "What would you like to accomplish?", "What task awaits?", "What's the mission today?", "What can be achieved?", "What project is ready to begin?", ]; const INITIAL_GREETING = GREETING_MESSAGES[Math.floor(Math.random() * GREETING_MESSAGES.length)]!; const SPINNER_FRAMES = ["◐", "◓", "◑", "◒"]; const PERMISSION_LABELS: Record = { allow_once: "Allow once", allow_always: "Always allow", reject_once: "Reject once", reject_always: "Always reject", }; const PERMISSION_KEYS: Record = { allow_once: "y", allow_always: "a", reject_once: "n", reject_always: "N", }; const INDENT = 3; const CONTENT_INDENT = 5; function Rule({ width }: { width: number }) { return {"─".repeat(Math.max(width, 1))}; } function Spinner({ idx }: { idx: number }) { return ( {SPINNER_FRAMES[idx % SPINNER_FRAMES.length]} ); } function Header({ width, status, loading, spinIdx, hasPendingPermission, turnInfo, }: { width: number; status: string; loading: boolean; spinIdx: number; hasPendingPermission: boolean; turnInfo?: { current: number; total: number }; }) { const statusColor = status === "ready" ? TEAL : isErrorStatus(status) ? CRANBERRY : TEXT_DIM; return ( goose · {status} {loading && !hasPendingPermission && ( {" "} )} {turnInfo && turnInfo.total > 1 && ( {turnInfo.current}/{turnInfo.total} {" "} )} ^C exit ); } function UserPrompt({ text }: { text: string }) { return ( {"❯ "} {text} ); } function PermissionDialog({ toolTitle, options, selectedIdx, width, }: { toolTitle: string; options: Array<{ optionId: string; name: string; kind: string }>; selectedIdx: number; width: number; }) { const dialogWidth = Math.min(width - CONTENT_INDENT - 2, 58); return ( 🔒 Permission required {toolTitle} {options.map((opt, i) => { const key = PERMISSION_KEYS[opt.kind] ?? String(i + 1); const label = PERMISSION_LABELS[opt.kind] ?? opt.name; const active = i === selectedIdx; return ( {active ? " ▸ " : " "} [{key}] {label} ); })} ↑↓ select · enter confirm · esc cancel ); } function QueuedMessage({ text }: { text: string }) { return ( ❯ {text} {" "} (queued) ); } function InputBar({ width, input, onChange, onSubmit, queued, scrollHint, }: { width: number; input: string; onChange: (v: string) => void; onSubmit: (v: string) => void; queued: boolean; scrollHint: boolean; }) { return ( {"❯ "} {scrollHint && shift+↑↓ history} {queued && ( message queued — will send when goose finishes )} ); } function buildTurnBodyLines({ turn, width, loading, status, spinIdx, pendingPermission, permissionIdx, expandedToolCall, }: { turn: Turn; width: number; loading: boolean; status: string; spinIdx: number; pendingPermission: PendingPermission | null; permissionIdx: number; expandedToolCall: string | null; }): React.ReactNode[] { const toolCallIds = turn.toolCallOrder; const toolCalls = turn.toolCalls; const featuredId = findFeaturedToolCallId(toolCallIds, toolCalls); const lines: React.ReactNode[] = []; lines.push(); for (const tcId of toolCallIds) { const tc = toolCalls.get(tcId); if (!tc) continue; if (tcId === featuredId || expandedToolCall === tcId) { const cardLines = buildToolCallCardLines(tc, CONTENT_INDENT, width, expandedToolCall === tcId, `tc-${tcId}`); lines.push(...cardLines); } else { lines.push( , ); } } if (turn.agentText) { if (toolCallIds.length > 0) { lines.push(); } const rendered = renderMarkdown(turn.agentText); const mdLines = rendered.split("\n"); for (let i = 0; i < mdLines.length; i++) { lines.push( {mdLines[i]} , ); } } if (loading && !pendingPermission) { lines.push( {" "} {status} , ); } if (pendingPermission) { lines.push( , ); } return lines; } function ScrollableBody({ lines, width, scrollOffset, }: { lines: React.ReactNode[]; width: number; scrollOffset: number; }) { const ref = useRef(null); const [measured, setMeasured] = useState(0); useEffect(() => { if (ref.current) { const { height } = measureElement(ref.current); if (height !== measured) setMeasured(height); } }); const total = lines.length; const availableHeight = measured || total; const needsScroll = total > availableHeight; const viewSize = needsScroll ? Math.max(availableHeight - 2, 1) : availableHeight; const maxOffset = Math.max(total - viewSize, 0); const clampedOffset = Math.min(Math.max(scrollOffset, 0), maxOffset); const endIdx = total - clampedOffset; const startIdx = Math.max(endIdx - viewSize, 0); const visible = lines.slice(startIdx, endIdx); const hiddenAbove = startIdx; const hiddenBelow = Math.max(total - endIdx, 0); return ( {needsScroll && ( {hiddenAbove > 0 ? ( ▲ {hiddenAbove} more (↑) ) : ( )} )} {visible} {needsScroll && ( {hiddenBelow > 0 ? ( ▼ {hiddenBelow} more (↓) ) : ( )} )} ); } function SplashScreen({ animFrame, width, height, status, loading, spinIdx, showInput, input, onInputChange, onInputSubmit, }: { animFrame: number; width: number; height: number; status: string; loading: boolean; spinIdx: number; showInput: boolean; input: string; onInputChange: (v: string) => void; onInputSubmit: (v: string) => void; }) { const frame = GOOSE_FRAMES[animFrame % GOOSE_FRAMES.length]!; const statusColor = status === "ready" ? TEAL : isErrorStatus(status) ? CRANBERRY : TEXT_DIM; const inputWidth = Math.min(56, width - 8); return ( {frame.map((line, i) => ( {line} ))} goose your on-machine AI agent {showInput ? ( {"❯ "} ) : ( {loading && } {status} )} ); } function App({ serverConnection, initialPrompt, }: { serverConnection: Stream | string; initialPrompt?: string; }) { const { exit } = useApp(); const { stdout } = useStdout(); const termWidth = stdout?.columns ?? 80; const termHeight = stdout?.rows ?? 24; const [turns, setTurns] = useState([]); const [input, setInput] = useState(""); const [loading, setLoading] = useState(true); const [status, setStatus] = useState("connecting…"); const [spinIdx, setSpinIdx] = useState(0); const [gooseFrame, setGooseFrame] = useState(0); const [bannerVisible, setBannerVisible] = useState(true); const [pendingPermission, setPendingPermission] = useState(null); const [permissionIdx, setPermissionIdx] = useState(0); const [queuedMessages, setQueuedMessages] = useState([]); const [viewTurnIdx, setViewTurnIdx] = useState(-1); const [expandedToolCall, setExpandedToolCall] = useState(null); const [scrollOffset, setScrollOffset] = useState(0); const clientRef = useRef(null); const sessionIdRef = useRef(null); const streamBuf = useRef(""); const sentInitialPrompt = useRef(false); const queueRef = useRef([]); const isProcessingRef = useRef(false); useEffect(() => { const t = setInterval(() => { setSpinIdx((i) => (i + 1) % SPINNER_FRAMES.length); setGooseFrame((f) => f + 1); }, 300); return () => clearInterval(t); }, []); useEffect(() => { if (turns.length > 0) setBannerVisible(false); }, [turns]); useEffect(() => { setExpandedToolCall(null); setScrollOffset(0); }, [viewTurnIdx, turns.length]); const appendAgent = useCallback((text: string) => { setTurns((prev) => { if (prev.length === 0) return prev; const last = { ...prev[prev.length - 1]! }; last.agentText = last.agentText + text; return [...prev.slice(0, -1), last]; }); }, []); const handleToolCall = useCallback( (tc: { toolCallId: string; title: string; status?: ToolCallStatus; kind?: ToolKind; rawInput?: unknown; rawOutput?: unknown; content?: ToolCallContent[]; locations?: Array<{ path: string; line?: number | null }>; }) => { setTurns((prev) => { if (prev.length === 0) return prev; const last = { ...prev[prev.length - 1]! }; const newMap = new Map(last.toolCalls); const info: ToolCallInfo = { toolCallId: tc.toolCallId, title: tc.title, status: tc.status ?? "pending", kind: tc.kind, rawInput: tc.rawInput, rawOutput: tc.rawOutput, content: tc.content, locations: tc.locations, }; newMap.set(tc.toolCallId, info); const newOrder = last.toolCallOrder.includes(tc.toolCallId) ? last.toolCallOrder : [...last.toolCallOrder, tc.toolCallId]; return [ ...prev.slice(0, -1), { ...last, toolCalls: newMap, toolCallOrder: newOrder }, ]; }); }, [], ); const handleToolCallUpdate = useCallback( (update: { toolCallId: string; title?: string | null; status?: ToolCallStatus | null; kind?: ToolKind | null; rawInput?: unknown; rawOutput?: unknown; content?: ToolCallContent[] | null; locations?: Array<{ path: string; line?: number | null }> | null; }) => { setTurns((prev) => { if (prev.length === 0) return prev; const last = { ...prev[prev.length - 1]! }; const newMap = new Map(last.toolCalls); const existing = newMap.get(update.toolCallId); if (!existing) return prev; const updated: ToolCallInfo = { ...existing }; if (update.title != null) updated.title = update.title; if (update.status != null) updated.status = update.status; if (update.kind != null) updated.kind = update.kind; if (update.rawInput !== undefined) updated.rawInput = update.rawInput; if (update.rawOutput !== undefined) updated.rawOutput = update.rawOutput; if (update.content != null) updated.content = update.content; if (update.locations != null) updated.locations = update.locations; newMap.set(update.toolCallId, updated); return [...prev.slice(0, -1), { ...last, toolCalls: newMap }]; }); }, [], ); const addUserTurn = useCallback((text: string) => { setTurns((prev) => [ ...prev, { userText: text, toolCalls: new Map(), toolCallOrder: [], agentText: "", }, ]); setViewTurnIdx(-1); setExpandedToolCall(null); setScrollOffset(0); }, []); const resolvePermission = useCallback( (option: { optionId: string } | "cancelled") => { if (!pendingPermission) return; const { resolve } = pendingPermission; if (option === "cancelled") { resolve({ outcome: { outcome: "cancelled" } }); } else { resolve({ outcome: { outcome: "selected", optionId: option.optionId }, }); } setPendingPermission(null); setPermissionIdx(0); }, [pendingPermission], ); const executePrompt = useCallback( async (text: string) => { const client = clientRef.current; const sid = sessionIdRef.current; if (!client || !sid) return; addUserTurn(text); setLoading(true); setStatus("thinking…"); streamBuf.current = ""; try { const result = await client.prompt({ sessionId: sid, prompt: [{ type: "text", text }], }); if (streamBuf.current) appendAgent(""); setStatus( result.stopReason === "end_turn" ? "ready" : `stopped: ${result.stopReason}`, ); } catch (e: unknown) { const errMsg = e instanceof Error ? e.message : String(e); setStatus(`error: ${errMsg}`); } finally { setLoading(false); } }, [appendAgent, addUserTurn], ); const processQueue = useCallback(async () => { if (isProcessingRef.current) return; isProcessingRef.current = true; while (queueRef.current.length > 0) { const next = queueRef.current.shift()!; setQueuedMessages([...queueRef.current]); await executePrompt(next); } isProcessingRef.current = false; }, [executePrompt]); const sendPrompt = useCallback( async (text: string) => { await executePrompt(text); if (queueRef.current.length > 0) processQueue(); }, [executePrompt, processQueue], ); useEffect(() => { let cancelled = false; (async () => { try { setStatus("initializing…"); const client = new GooseClient( () => ({ sessionUpdate: async (params: SessionNotification) => { const update = params.update; if (update.sessionUpdate === "agent_message_chunk") { if (update.content.type === "text") { streamBuf.current += update.content.text; appendAgent(update.content.text); } } else if (update.sessionUpdate === "tool_call") { handleToolCall({ toolCallId: update.toolCallId, title: update.title, status: update.status, kind: update.kind, rawInput: update.rawInput, rawOutput: update.rawOutput, content: update.content, locations: update.locations, }); } else if (update.sessionUpdate === "tool_call_update") { handleToolCallUpdate({ toolCallId: update.toolCallId, title: update.title, status: update.status, kind: update.kind, rawInput: update.rawInput, rawOutput: update.rawOutput, content: update.content, locations: update.locations, }); } }, requestPermission: async ( params: RequestPermissionRequest, ): Promise => { return new Promise((resolve) => { const toolTitle = params.toolCall.title ?? "unknown tool"; const options = params.options.map((opt) => ({ optionId: opt.optionId, name: opt.name, kind: opt.kind, })); setPendingPermission({ toolTitle, options, resolve }); setPermissionIdx(0); }); }, }), serverConnection, ); if (cancelled) return; clientRef.current = client; setStatus("handshaking…"); await client.initialize({ protocolVersion: 0, clientInfo: { name: "goose-text", version: "0.1.0" }, clientCapabilities: {}, }); if (cancelled) return; setStatus("creating session…"); const session = await client.newSession({ cwd: process.cwd(), mcpServers: [], }); if (cancelled) return; sessionIdRef.current = session.sessionId; setLoading(false); setStatus("ready"); if (initialPrompt && !sentInitialPrompt.current) { sentInitialPrompt.current = true; await sendPrompt(initialPrompt); setTimeout(() => exit(), 100); } } catch (e: unknown) { if (cancelled) return; const errMsg = e instanceof Error ? e.message : String(e); setStatus(`failed: ${errMsg}`); setLoading(false); } })(); return () => { cancelled = true; }; }, [ serverConnection, initialPrompt, sendPrompt, appendAgent, handleToolCall, handleToolCallUpdate, exit, ]); const handleSubmit = useCallback( (value: string) => { const trimmed = value.trim(); if (!trimmed) return; setInput(""); setViewTurnIdx(-1); setExpandedToolCall(null); setScrollOffset(0); if (loading || isProcessingRef.current) { queueRef.current.push(trimmed); setQueuedMessages([...queueRef.current]); } else { sendPrompt(trimmed); } }, [loading, sendPrompt], ); useInput((ch, key) => { if (key.escape || (ch === "c" && key.ctrl)) { if (pendingPermission) { resolvePermission("cancelled"); return; } exit(); } if (pendingPermission) { const opts = pendingPermission.options; if (key.upArrow) { setPermissionIdx((i) => (i - 1 + opts.length) % opts.length); return; } if (key.downArrow) { setPermissionIdx((i) => (i + 1) % opts.length); return; } if (key.return) { const selected = opts[permissionIdx]; if (selected) resolvePermission({ optionId: selected.optionId }); return; } const keyMap: Record = { y: "allow_once", a: "allow_always", n: "reject_once", N: "reject_always", }; const targetKind = keyMap[ch]; if (targetKind) { const match = opts.find((o) => o.kind === targetKind); if (match) resolvePermission({ optionId: match.optionId }); } return; } if (key.tab) { const effectiveIdx = viewTurnIdx === -1 ? turns.length - 1 : viewTurnIdx; const currentTurn = turns[effectiveIdx]; if (!currentTurn || currentTurn.toolCallOrder.length === 0) return; const featuredId = findFeaturedToolCallId(currentTurn.toolCallOrder, currentTurn.toolCalls); if (!featuredId) return; setExpandedToolCall((prev) => (prev === featuredId ? null : featuredId)); return; } if (key.upArrow && !key.shift && !key.meta) { setScrollOffset((prev) => prev + 3); return; } if (key.downArrow && !key.shift && !key.meta) { setScrollOffset((prev) => Math.max(prev - 3, 0)); return; } if (key.upArrow && key.shift) { setTurns((currentTurns) => { if (currentTurns.length <= 1) return currentTurns; setViewTurnIdx((prev) => { const effectiveIdx = prev === -1 ? currentTurns.length - 1 : prev; return Math.max(effectiveIdx - 1, 0); }); return currentTurns; }); return; } if (key.downArrow && key.shift) { setTurns((currentTurns) => { if (currentTurns.length <= 1) return currentTurns; setViewTurnIdx((prev) => { if (prev === -1) return -1; const next = prev + 1; return next >= currentTurns.length ? -1 : next; }); return currentTurns; }); return; } }); const GUTTER = 2; const innerWidth = Math.max(termWidth - GUTTER * 2, 20); if (bannerVisible) { return ( ); } const effectiveTurnIdx = viewTurnIdx === -1 ? turns.length - 1 : viewTurnIdx; const currentTurn = turns[effectiveTurnIdx]; const isViewingHistory = viewTurnIdx !== -1 && viewTurnIdx < turns.length - 1; const isLatest = !isViewingHistory; const emptyTurn: Turn = { userText: "", toolCalls: new Map(), toolCallOrder: [], agentText: "", }; const bodyLines = buildTurnBodyLines({ turn: currentTurn ?? emptyTurn, width: innerWidth, loading: isLatest && loading, status, spinIdx, pendingPermission: isLatest ? pendingPermission : null, permissionIdx, expandedToolCall, }); const allBodyLines = isLatest ? [ ...bodyLines, ...queuedMessages.map((text, i) => ( )), ] : bodyLines; return (

1 ? { current: effectiveTurnIdx + 1, total: turns.length } : undefined } /> {currentTurn ? ( <> ) : ( )} {isViewingHistory && ( turn {effectiveTurnIdx + 1}/{turns.length} — shift+↓ to return )} {!isViewingHistory && !pendingPermission && !initialPrompt && ( 0} scrollHint={turns.length > 1} /> )} ); } const cli = meow( ` Usage $ goose Options --server, -s Server URL (default: auto-launch bundled server) --text, -t Send a single prompt and exit `, { importMeta: import.meta, flags: { server: { type: "string", shortFlag: "s" }, text: { type: "string", shortFlag: "t" }, }, }, ); function findServerBinary(): string | null { const __dirname = dirname(fileURLToPath(import.meta.url)); const candidates = [ join(__dirname, "..", "server-binary.json"), join(__dirname, "server-binary.json"), ]; for (const candidate of candidates) { try { const data = JSON.parse(readFileSync(candidate, "utf-8")); return data.binaryPath ?? null; } catch { // not found here, try next } } return null; } let serverProcess: ReturnType | null = null; async function main() { let serverConnection: Stream | string; if (cli.flags.server) { serverConnection = cli.flags.server; } else { const binary = findServerBinary(); if (!binary) { console.error( "No goose binary found. Use --server or install the native package.", ); process.exit(1); } serverProcess = spawn(binary, ["acp"], { stdio: ["pipe", "pipe", "ignore"], detached: false, }); serverProcess.on("error", (err) => { console.error(`Failed to start goose acp: ${err.message}`); process.exit(1); }); const output = Writable.toWeb(serverProcess.stdin!) as WritableStream; const input = Readable.toWeb(serverProcess.stdout!) as ReadableStream; serverConnection = ndJsonStream(output, input); } const { waitUntilExit } = render( , ); await waitUntilExit(); cleanup(); } function cleanup() { if (serverProcess && !serverProcess.killed) { serverProcess.kill(); } } process.on("exit", cleanup); process.on("SIGINT", () => { cleanup(); process.exit(0); }); process.on("SIGTERM", () => { cleanup(); process.exit(0); }); main().catch((err) => { console.error(err); cleanup(); process.exit(1); });