@code-yeongyu/senpi 2026.7.25 → 2026.7.26

package/docs/neo.md

@@ -1,111 +0,0 @@
-# neo (Go TUI) — coding-agent integration notes
-
-> Minimal scaffold. Expanded by plan task 22 (docs + infra-sync). This file
-> currently covers only the pieces landed by task 15 (the TypeScript daemon).
-
-## Overview
-
-`senpi --neo` launches a Go-native terminal UI that drives the existing agent
-runtime over the JSONL RPC protocol. Multiple neo windows in the SAME cwd share
-one backend via a small TypeScript **daemon**, instead of each spawning its own
-runtime. `--neo-isolated` opts out of sharing (per-instance stdio backend).
-
-## Daemon architecture (task 15)
-
-### Process model
-
-- `senpi --listen <socket>` runs the daemon **supervisor**. It binds the socket,
-  self-registers, and serves connections. It does NOT construct an
-  `AgentSessionRuntime` in the supervisor process.
-- Each accepted connection is served by its own child `senpi --mode rpc`
-  **worker** process, spawned with the connection's cwd and its own
-  `SENPI_CODING_AGENT_DIR`. The worker is a standard single-connection rpc
-  runtime with its own module state and its own `AuthStorage`.
-
-### Why one worker process per connection (isolation)
-
-Running N `createAgentSessionRuntime` instances concurrently in ONE node process
-is not safe: pi-ai keeps a **process-global provider registry** that
-`ModelRegistry.refresh()` / `AgentSession.reload()` reset
-(`resetApiProviders()` / `resetOAuthProviders()`), and pi-agent-core mints entry
-IDs from a **module-level UUIDv7 counter**. Two concurrent in-process runtimes
-would cross-talk through both. Both live in shared libraries that are out of
-scope to change, so the daemon uses child-process workers instead — real
-concurrency, full isolation, and `--api-key` that can never leak across
-connections. See `.omo/evidence/task-15-neo-go-tui.md` §1 for the full spike.
-
-### Handshake
-
-A connection's first line is a `hello`:
-
-```json
-{"type":"hello","token":"<registry token>","version":1,"capabilities":[],"runtimeOptions":{...}}
-```
-
-The daemon replies `{"type":"welcome","version":1}` or
-`{"type":"refuse","code":"bad_token|version_mismatch|unsupported_options|malformed_hello","reason":"..."}`.
-`runtimeOptions` is the typed `NeoRuntimeOptions` payload (every classic runtime
-flag: provider/model/models/thinking/api-key, session selection, approval, tool
-scoping, resource loading, system prompt overrides, extension flags, and raw
-initial inputs). Its field
-set is generated from the classic runtime-construction path by an extraction
-test — a new consumer of a `parsed.*` field fails the test until it is threaded
-through the payload or documented as a carve-out.
-
-**Carve-out:** piped-stdin input never reaches the daemon — a TTY-less
-`senpi --neo` falls back to classic print-mode in the launcher.
-
-### Registry / race protocol
-
-- The daemon binds the socket FIRST — the bind is the mutex. The race loser gets
-  `EADDRINUSE` and its client attaches to the winner.
-- After a successful `listen`, and only with `--register`, the daemon atomically
-  writes `~/.senpi/agent/neo-daemon/<cwd-key>.json` (temp file + `rename`, mode
-  `0600`) as the LAST listen step. `<cwd-key>` uses the same safe-path scheme as
-  the session manager. Clients NEVER write the registry.
-- On spawn, a stale record (dead pid) and its leftover socket file are cleaned up
-  before binding.
-
-### Connection lifecycle
-
-There is no live-reattach lease. A socket disconnect aborts that connection's
-in-flight turn and disposes its worker. Sessions persist incrementally to disk,
-so recovery is resume-from-file (the Go client reloads via `get_state` +
-`get_entries{since}`). The daemon shuts down after a configurable no-connection
-idle period (`neoDaemon.idleShutdownMs` setting, default 30 minutes; `0`
-disables). The last client does NOT kill the daemon — the idle timer owns
-lifecycle.
-
-## Project-trust semantics in the daemon
-
-Each worker runs `--mode rpc`, which is **non-interactive**. In rpc mode the
-project-trust context has `hasUI: false`, so `resolveProjectTrusted` returns
-`false` for project-local resources unless:
-
-- the global `defaultProjectTrust` setting is `"always"`, or
-- the connection passes `--approve` (`projectTrustOverride: true`) in its
-  `runtimeOptions`.
-
-This is the same behavior as classic `senpi --mode rpc` today (the daemon adds no
-new trust surface). The classic **interactive** TUI prompts for trust; the neo
-client is responsible for surfacing an equivalent confirm through the
-extension-UI bridge and forwarding the user's choice as `--approve`/`--no-approve`
-(wired in plan task 13). No project-local code is trusted implicitly by the
-daemon.
-
-## cwd-threading audit (per-user-daemon safety)
-
-Verdict: **per-cwd, child-per-connection is safe** with respect to cwd.
-
-- There are **zero** `process.chdir()` calls in `packages/coding-agent/src`.
-- Tool execution is closure-captured: each tool is created with an explicit
-  `cwd` (from `AgentSession.config.cwd`) and threads it to every spawn/path call.
-  The bash tool passes `cwd` explicitly to `spawn(...)`; it never inherits
-  `process.cwd()`.
-- `resolvePath()` / `SessionManager` fall back to `process.cwd()` only as a
-  default when no explicit base/cwd is given; the runtime path always passes one.
-- Because each connection is its own child process spawned with an explicit
-  `cwd`, the child's `process.cwd()` is already the client's directory, so even
-  the fallback paths resolve correctly. No cross-connection cwd hazard remains.
-
-Per-cwd remains the default regardless (one daemon serves one cwd).

package/node_modules/@code-yeongyu/senpi-codemode/src/codemode/runtime.ts

@@ -1,258 +0,0 @@
-import type { KernelToHostMessage } from "../bridge/protocol.ts";
-import type { AgentExecuteTool } from "../bridges/agent-bridge.ts";
-import { JavaScriptKernel } from "../kernels/js/context-manager.ts";
-import { marshalToolResult } from "../tool/image.ts";
-
-const MAX_ACTIVE_CELLS = 4;
-const MAX_PENDING_OUTPUT_CHARS = 100_000;
-const MAX_TERMINAL_ERROR_CHARS = 4_096;
-const RECURSIVE_TOOLS = new Set(["eval", "exec", "wait"]);
-
-export type CodeModeCellState = "yielded" | "result" | "terminated" | "error" | "missing";
-
-export interface CodeModeObservation {
-	readonly cellId: string;
-	readonly state: CodeModeCellState;
-	readonly output: string;
-	readonly error?: string;
-}
-
-export interface CodeModeRuntimeOptions {
-	readonly sessionId: string;
-	readonly cwd: string;
-	readonly parallelPoolWidth: number;
-	readonly executeTool: AgentExecuteTool;
-}
-
-export class CodeModeCapacityError extends Error {
-	readonly name = "CodeModeCapacityError";
-
-	constructor() {
-		super(`Code Mode supports at most ${MAX_ACTIVE_CELLS} active cells`);
-	}
-}
-
-export class CodeModeSessionRuntime {
-	readonly #options: CodeModeRuntimeOptions;
-	readonly #cells = new Map<string, CodeModeCell>();
-	#nextCell = 0;
-	#disposed = false;
-
-	constructor(options: CodeModeRuntimeOptions) {
-		this.#options = options;
-	}
-
-	async execute(code: string, yieldTimeMs: number, signal: AbortSignal | undefined): Promise<CodeModeObservation> {
-		this.#assertActive();
-		const cellId = `exec-${++this.#nextCell}`;
-		if (signal?.aborted) return { cellId, state: "terminated", output: "" };
-		if (this.#cells.size >= MAX_ACTIVE_CELLS) throw new CodeModeCapacityError();
-		const cell = new CodeModeCell(cellId, this.#options);
-		this.#cells.set(cellId, cell);
-		cell.start(code);
-		const observation = await cell.observe(yieldTimeMs, signal);
-		this.#releaseIfTerminal(observation);
-		return observation;
-	}
-
-	async wait(
-		cellId: string,
-		yieldTimeMs: number,
-		terminate: boolean,
-		signal: AbortSignal | undefined,
-	): Promise<CodeModeObservation> {
-		const cell = this.#cells.get(cellId);
-		if (cell === undefined) return { cellId, state: "missing", output: "" };
-		const observation = terminate ? await cell.terminate() : await cell.observe(yieldTimeMs, signal);
-		this.#releaseIfTerminal(observation);
-		return observation;
-	}
-
-	async dispose(): Promise<void> {
-		if (this.#disposed) return;
-		this.#disposed = true;
-		const cells = [...this.#cells.values()];
-		this.#cells.clear();
-		await Promise.all(cells.map((cell) => cell.terminate()));
-	}
-
-	#releaseIfTerminal(observation: CodeModeObservation): void {
-		if (observation.state !== "yielded") this.#cells.delete(observation.cellId);
-	}
-
-	#assertActive(): void {
-		if (this.#disposed) throw new Error("Code Mode session has been disposed");
-	}
-}
-
-class CodeModeCell {
-	readonly #id: string;
-	readonly #options: CodeModeRuntimeOptions;
-	readonly #kernel: JavaScriptKernel;
-	readonly #abort = new AbortController();
-	#output = "";
-	#outputTruncated = false;
-	#completion: Promise<void> | undefined;
-	#state: "running" | "result" | "terminated" | "error" = "running";
-	#error: string | undefined;
-
-	constructor(id: string, options: CodeModeRuntimeOptions) {
-		this.#id = id;
-		this.#options = options;
-		this.#kernel = new JavaScriptKernel({
-			sessionId: `${options.sessionId}:${id}`,
-			cwd: options.cwd,
-			parallelPoolWidth: options.parallelPoolWidth,
-			onMessage: (message) => this.#handleMessage(message),
-		});
-	}
-
-	start(code: string): void {
-		this.#completion = this.#kernel
-			.run({ cellId: this.#id, code })
-			.then((result) => {
-				if (this.#state !== "running") return;
-				if (result.ok) {
-					this.#state = "result";
-					if (result.valueRepr) this.#appendOutput(`${result.valueRepr}\n`);
-					return;
-				}
-				this.#state = "error";
-				this.#error = truncateTerminalError(result.error.message);
-			})
-			.catch((error: unknown) => {
-				if (this.#state !== "running") return;
-				this.#state = "error";
-				this.#error = truncateTerminalError(error instanceof Error ? error.message : String(error));
-			})
-			.finally(async () => {
-				if (this.#state !== "running") await this.#kernel.close();
-			});
-	}
-
-	async observe(yieldTimeMs: number, signal: AbortSignal | undefined): Promise<CodeModeObservation> {
-		if (signal?.aborted) return await this.terminate();
-		if (this.#state !== "running") return this.#observation();
-		const completion = this.#completion;
-		if (completion === undefined) throw new Error("Code Mode cell has not started");
-		const timeout = Math.max(1, Math.trunc(yieldTimeMs));
-		let timer: ReturnType<typeof setTimeout> | undefined;
-		let abortListener: (() => void) | undefined;
-		const timedOut = new Promise<"yielded">((resolve) => {
-			timer = setTimeout(() => resolve("yielded"), timeout);
-		});
-		const completed = completion.then(() => "completed" as const);
-		const aborted = new Promise<"aborted">((resolve) => {
-			if (!signal) return;
-			abortListener = () => resolve("aborted");
-			signal.addEventListener("abort", abortListener, { once: true });
-		});
-		try {
-			const outcome = await Promise.race([completed, timedOut, aborted]);
-			if (outcome === "aborted") return await this.terminate();
-			return this.#observation();
-		} finally {
-			if (timer !== undefined) clearTimeout(timer);
-			if (abortListener && signal) signal.removeEventListener("abort", abortListener);
-		}
-	}
-
-	async terminate(): Promise<CodeModeObservation> {
-		if (this.#state === "terminated") return this.#observation();
-		if (this.#state === "result" || this.#state === "error") return this.#observation();
-		this.#state = "terminated";
-		this.#abort.abort(new Error("Code Mode cell terminated"));
-		try {
-			await this.#kernel.interrupt("Code Mode cell terminated");
-		} finally {
-			await this.#kernel.close();
-		}
-		return this.#observation();
-	}
-
-	#handleMessage(message: KernelToHostMessage): void {
-		if (message.type === "text") {
-			this.#appendOutput(message.data);
-			return;
-		}
-		if (message.type === "display") {
-			this.#appendOutput(`[display ${message.mimeType}]\n`);
-			return;
-		}
-		if (message.type === "tool-call") void this.#invokeTool(message);
-	}
-
-	async #invokeTool(message: Extract<KernelToHostMessage, { type: "tool-call" }>): Promise<void> {
-		if (RECURSIVE_TOOLS.has(message.toolName)) {
-			this.#kernel.deliverToolReply({
-				type: "tool-reply",
-				callId: message.callId,
-				ok: false,
-				error: { message: `recursive Code Mode tool "${message.toolName}" is not allowed` },
-			});
-			return;
-		}
-		if (this.#options.executeTool.isToolAvailable?.(message.toolName) === false) {
-			this.#kernel.deliverToolReply({
-				type: "tool-reply",
-				callId: message.callId,
-				ok: false,
-				error: { message: `nested tool "${message.toolName}" is not active` },
-			});
-			return;
-		}
-		try {
-			const result = await this.#options.executeTool(message.toolName, message.args, { signal: this.#abort.signal });
-			this.#kernel.deliverToolReply({
-				type: "tool-reply",
-				callId: message.callId,
-				ok: true,
-				value: marshalToolResult(result),
-			});
-		} catch (error) {
-			this.#kernel.deliverToolReply({
-				type: "tool-reply",
-				callId: message.callId,
-				ok: false,
-				error: { message: error instanceof Error ? error.message : String(error) },
-			});
-		}
-	}
-
-	#observation(): CodeModeObservation {
-		let output = this.#output;
-		this.#output = "";
-		if (this.#outputTruncated) {
-			output += "\n[output truncated]\n";
-			this.#outputTruncated = false;
-		}
-		if (this.#state === "running") return { cellId: this.#id, state: "yielded", output };
-		if (this.#state === "terminated") return { cellId: this.#id, state: "terminated", output };
-		if (this.#state === "error") {
-			const error = this.#error ?? "Code Mode cell failed";
-			if (output !== "") output += output.endsWith("\n") ? error : `\n${error}`;
-			else output = error;
-			return { cellId: this.#id, state: "error", output, error };
-		}
-		return { cellId: this.#id, state: "result", output };
-	}
-
-	#appendOutput(value: string): void {
-		const remaining = MAX_PENDING_OUTPUT_CHARS - this.#output.length;
-		if (remaining <= 0) {
-			this.#outputTruncated = true;
-			return;
-		}
-		if (value.length > remaining) {
-			this.#output += value.slice(0, remaining);
-			this.#outputTruncated = true;
-			return;
-		}
-		this.#output += value;
-	}
-}
-
-function truncateTerminalError(message: string): string {
-	if (message.length <= MAX_TERMINAL_ERROR_CHARS) return message;
-	return `${message.slice(0, MAX_TERMINAL_ERROR_CHARS)}\n[error truncated]`;
-}

package/node_modules/@code-yeongyu/senpi-codemode/src/codemode/tools.ts

@@ -1,106 +0,0 @@
-import type { AgentToolResult, ToolDefinition } from "@code-yeongyu/senpi";
-import { type Static, Type } from "typebox";
-import type { CodeModeCellState, CodeModeObservation, CodeModeSessionRuntime } from "./runtime.ts";
-
-const DEFAULT_YIELD_TIME_MS = 10_000;
-
-const execInputSchema = Type.Object({
-	code: Type.String({ minLength: 1, description: "JavaScript program to execute in a dedicated Code Mode cell." }),
-	yield_time_ms: Type.Optional(
-		Type.Integer({ minimum: 1, maximum: 60_000, description: "Return a yielded cell after this many milliseconds." }),
-	),
-});
-
-const waitInputSchema = Type.Object({
-	cell_id: Type.String({ minLength: 1, description: "Code Mode cell id returned by exec." }),
-	yield_time_ms: Type.Optional(
-		Type.Integer({ minimum: 1, maximum: 60_000, description: "Return again after this many milliseconds." }),
-	),
-	terminate: Type.Optional(Type.Boolean({ description: "Interrupt and close the cell instead of waiting." })),
-});
-
-type ExecInput = Static<typeof execInputSchema>;
-type WaitInput = Static<typeof waitInputSchema>;
-
-export interface CodeModeToolDetails {
-	readonly cellId: string;
-	readonly state: CodeModeCellState;
-	readonly isError?: boolean;
-}
-
-export type CodeModeTool =
-	| ToolDefinition<typeof execInputSchema, CodeModeToolDetails>
-	| ToolDefinition<typeof waitInputSchema, CodeModeToolDetails>;
-
-export interface CreateCodeModeToolsOptions {
-	readonly runtime: CodeModeSessionRuntime;
-}
-
-export function createCodeModeTools(options: CreateCodeModeToolsOptions): {
-	readonly exec: ToolDefinition<typeof execInputSchema, CodeModeToolDetails>;
-	readonly wait: ToolDefinition<typeof waitInputSchema, CodeModeToolDetails>;
-} {
-	return {
-		exec: {
-			name: "exec",
-			label: "GPT Code Mode Exec",
-			description:
-				"Run JavaScript in a dedicated GPT Code Mode cell. Call active Senpi tools as `tools.<name>(args)`. " +
-				"If the cell yields, call wait with its cell_id.",
-			promptSnippet: "Execute JavaScript that composes active tools in a dedicated Code Mode cell.",
-			promptGuidelines: [
-				"Use exec for bounded JavaScript composition of active tools; use eval for persistent multi-language analysis.",
-				"Call wait only when exec reports a yielded cell, and terminate abandoned cells with wait({ cell_id, terminate: true }).",
-			],
-			parameters: execInputSchema,
-			executionMode: "sequential",
-			async execute(_toolCallId, params: ExecInput, signal) {
-				return resultFrom(
-					await options.runtime.execute(params.code, params.yield_time_ms ?? DEFAULT_YIELD_TIME_MS, signal),
-				);
-			},
-		},
-		wait: {
-			name: "wait",
-			label: "GPT Code Mode Wait",
-			description: "Observe a yielded GPT Code Mode cell or terminate it.",
-			promptSnippet: "Wait for, or terminate, a yielded GPT Code Mode cell.",
-			parameters: waitInputSchema,
-			executionMode: "sequential",
-			async execute(_toolCallId, params: WaitInput, signal) {
-				return resultFrom(
-					await options.runtime.wait(
-						params.cell_id,
-						params.yield_time_ms ?? DEFAULT_YIELD_TIME_MS,
-						params.terminate ?? false,
-						signal,
-					),
-				);
-			},
-		},
-	};
-}
-
-function resultFrom(observation: CodeModeObservation): AgentToolResult<CodeModeToolDetails> {
-	const text =
-		observation.output ||
-		(observation.state === "yielded"
-			? `Code Mode cell ${observation.cellId} is still running. Call wait with this cell_id.`
-			: observation.state === "missing"
-				? `Code Mode cell ${observation.cellId} does not exist.`
-				: observation.state === "terminated"
-					? `Code Mode cell ${observation.cellId} was terminated.`
-					: (observation.error ?? `Code Mode cell ${observation.cellId} completed.`));
-	return {
-		content: [{ type: "text", text }],
-		details: {
-			cellId: observation.cellId,
-			state: observation.state,
-			...(observation.state === "error" || observation.state === "missing" ? { isError: true } : {}),
-		},
-	};
-}
-
-export function isGptCodeModeModel(modelId: string | undefined): boolean {
-	return modelId !== undefined && /(^|[/.:])gpt[-.]/iu.test(modelId);
-}