@vibedeckx/darwin-arm64 0.1.10

package/dist/agent-provider.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Agent Provider Interface
+ *
+ * Defines the contract that all agent providers must implement.
+ * Providers handle agent-specific logic: binary detection, spawn config,
+ * stdout parsing, and stdin formatting.
+ */
+import type { AgentType, ContentPart } from "./agent-types.js";
+export type { AgentType };
+export interface SpawnConfig {
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+    shell?: boolean;
+}
+export type ParsedAgentEvent = {
+    type: "text";
+    content: string;
+} | {
+    type: "tool_use";
+    tool: string;
+    input: unknown;
+    toolUseId: string;
+} | {
+    type: "tool_result";
+    tool: string;
+    output: string;
+    toolUseId: string;
+} | {
+    type: "thinking";
+    content: string;
+} | {
+    type: "system";
+    content: string;
+} | {
+    type: "error";
+    message: string;
+} | {
+    type: "result";
+    subtype: "success" | "error";
+    error?: string;
+    duration_ms?: number;
+    cost_usd?: number;
+    input_tokens?: number;
+    output_tokens?: number;
+} | {
+    type: "approval_request";
+    requestType: "command";
+    requestId: string;
+    command: string;
+    cwd?: string;
+} | {
+    type: "approval_request";
+    requestType: "fileChange";
+    requestId: string;
+    changes: Array<{
+        path: string;
+        diff?: string;
+        kind: string;
+    }>;
+} | {
+    type: "stdin_write";
+    content: string;
+};
+export interface AgentProvider {
+    /** Detect the agent binary on the system. Returns path or null if not found. */
+    detectBinary(): string | null;
+    /** Build the spawn configuration for launching the agent process. */
+    buildSpawnConfig(cwd: string, permissionMode: "plan" | "edit"): SpawnConfig;
+    /** Parse a single stdout line into zero or more agent events. */
+    parseStdoutLine(line: string, sessionId: string): ParsedAgentEvent[];
+    /** Format user input for writing to the agent's stdin. */
+    formatUserInput(content: string | ContentPart[], sessionId: string): string;
+    /** Format an approval response (optional — only needed for agents with approval flow). */
+    formatApprovalResponse?(requestId: string, decision: string, sessionId: string): string;
+    /** Called when a new session is created for this agent type. */
+    onSessionCreated?(sessionId: string): void;
+    /** Called when a session is destroyed/deleted for this agent type. */
+    onSessionDestroyed?(sessionId: string): void;
+    /** Return initialization messages to write to stdin immediately after spawn (optional). */
+    getInitializationMessages?(sessionId: string): string | null;
+    /**
+     * Format an interrupt/cancel message to send via stdin (optional).
+     * Returns a string to write to stdin to cancel the current execution,
+     * or null to fall back to SIGTERM.
+     */
+    formatInterrupt?(sessionId: string): string | null;
+    /** Human-readable display name for this agent. */
+    getDisplayName(): string;
+    /** The agent type identifier. */
+    getAgentType(): AgentType;
+}

package/dist/agent-provider.js

@@ -0,0 +1,8 @@
+/**
+ * Agent Provider Interface
+ *
+ * Defines the contract that all agent providers must implement.
+ * Providers handle agent-specific logic: binary detection, spawn config,
+ * stdout parsing, and stdin formatting.
+ */
+export {};

package/dist/agent-session-manager.d.ts

@@ -0,0 +1,165 @@
+import { type ChildProcess } from "child_process";
+import type { WebSocket } from "@fastify/websocket";
+import type { Storage } from "./storage/types.js";
+import type { AgentMessage, AgentSessionStatus, AgentType, ContentPart } from "./agent-types.js";
+import { type Patch } from "./conversation-patch.js";
+import type { EventBus } from "./event-bus.js";
+import { EntryIndexProvider, EntryTracker } from "./entry-index-provider.js";
+interface MessageStore {
+    /** All patches sent for this session (for history replay) */
+    patches: Patch[];
+    /** Reconstructed entries from patches (for quick access) */
+    entries: AgentMessage[];
+    /** Index provider for monotonic indices */
+    indexProvider: EntryIndexProvider;
+    /** Tracks tool_use/tool_result blocks by ID to prevent duplicates from streaming replays */
+    toolTracker: EntryTracker;
+    /** Index of the current streaming assistant message, or null if not streaming */
+    currentAssistantIndex: number | null;
+}
+interface RunningSession {
+    id: string;
+    projectId: string;
+    branch: string | null;
+    process: ChildProcess | null;
+    dormant: boolean;
+    store: MessageStore;
+    subscribers: Set<WebSocket>;
+    status: AgentSessionStatus;
+    buffer: string;
+    skipDb: boolean;
+    permissionMode: "plan" | "edit";
+    agentType: AgentType;
+}
+export declare class AgentSessionManager {
+    private sessions;
+    private storage;
+    private eventBus;
+    constructor(storage: Storage);
+    setEventBus(eventBus: EventBus): void;
+    /**
+     * Get or create an agent session for a branch
+     */
+    getOrCreateSession(projectId: string, branch: string | null, projectPath: string, skipDb?: boolean, permissionMode?: "plan" | "edit", agentType?: AgentType): string;
+    /**
+     * Kill an agent process and its entire process tree.
+     * Uses negative PID to signal the process group (requires detached: true at spawn).
+     */
+    private killProcess;
+    /**
+     * Spawn agent process using the provider for this session's agent type
+     */
+    private spawnAgent;
+    /**
+     * Handle stdout data from agent process
+     */
+    private handleStdout;
+    /**
+     * Process a single parsed agent event (provider-agnostic).
+     * Routes each ParsedAgentEvent to the appropriate message store / broadcast action.
+     * Includes input_tokens/output_tokens in taskCompleted broadcast for token reporting.
+     */
+    private processAgentEvent;
+    /**
+     * Update or add an assistant message using JSON Patch semantics
+     * This is the key method that handles streaming updates correctly
+     */
+    private updateAssistantMessage;
+    /**
+     * Push a new entry with ADD patch
+     */
+    private pushEntry;
+    /**
+     * Persist a single entry to the database
+     */
+    private persistEntry;
+    /**
+     * Finalize and persist the current streaming assistant message
+     */
+    private finalizeStreamingEntry;
+    /**
+     * Send a user message to the agent
+     */
+    sendUserMessage(sessionId: string, content: string | ContentPart[], projectPath?: string): boolean;
+    /**
+     * Send an approval response to the agent process (for agents with approval flow).
+     * Returns false if session not found, not running, or provider doesn't support approvals.
+     */
+    sendApprovalResponse(sessionId: string, requestId: string, decision: string): boolean;
+    /**
+     * Subscribe to session updates (WebSocket connection)
+     */
+    subscribe(sessionId: string, ws: WebSocket): (() => void) | null;
+    /**
+     * Get all messages for a session (reconstructed from patches)
+     */
+    getMessages(sessionId: string): AgentMessage[];
+    /**
+     * Get session info
+     */
+    getSession(sessionId: string): RunningSession | null;
+    /**
+     * Get session by branch
+     */
+    getSessionByBranch(projectId: string, branch: string | null): RunningSession | null;
+    /**
+     * Get all sessions for a project regardless of branch
+     */
+    getSessionsByProject(projectId: string): RunningSession[];
+    /**
+     * Check if a session is running
+     */
+    isRunning(sessionId: string): boolean;
+    /**
+     * Stop a session — kills the process but preserves conversation history
+     * (like pressing ESC in Claude Code). The session becomes dormant so the
+     * next user message will spawn a fresh process with full context replay.
+     * The WebSocket stays alive so the UI remains connected.
+     */
+    stopSession(sessionId: string): boolean;
+    /**
+     * Delete a session (stop and remove)
+     */
+    deleteSession(sessionId: string): boolean;
+    /**
+     * Restart a session (stop process, clear history, respawn)
+     * Returns the same session ID with a fresh conversation
+     */
+    restartSession(sessionId: string, projectPath: string, agentType?: AgentType): boolean;
+    /**
+     * Switch permission mode for a session (preserves conversation history)
+     */
+    switchMode(sessionId: string, projectPath: string, newMode: "plan" | "edit", initialMessage?: string): boolean;
+    /**
+     * Accept a plan and restart the session in edit mode
+     */
+    acceptPlanAndRestart(sessionId: string, projectPath: string, planContent: string): boolean;
+    /**
+     * Build full conversation context from message entries for context transfer.
+     * Uses XML-tagged format to prevent Claude from confusing historical context
+     * with actual tool executions in the current session.
+     */
+    private buildFullConversationContext;
+    /**
+     * Wake a dormant session: spawn process, send full context + user message
+     */
+    private wakeDormantSession;
+    /**
+     * Restore sessions from database on startup.
+     * Creates dormant RunningSession objects with process=null for sessions that have entries.
+     */
+    restoreSessionsFromDb(): void;
+    /**
+     * Kill all active session processes and clear state for graceful shutdown
+     */
+    shutdown(): void;
+    /**
+     * Broadcast a JSON patch to all subscribers
+     */
+    private broadcastPatch;
+    /**
+     * Broadcast a raw message to all subscribers
+     */
+    private broadcastRaw;
+}
+export {};