@finityno/claude-code-acp 0.13.2

package/dist/subagent-tracker.d.ts

@@ -0,0 +1,193 @@
+import { AgentSideConnection } from "@agentclientprotocol/sdk";
+import { Logger } from "./acp-agent.js";
+/**
+ * Subagent status lifecycle
+ */
+export type SubagentStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+/**
+ * Subagent type from Claude Code Task tool
+ */
+export type SubagentType = "Bash" | "general-purpose" | "statusline-setup" | "Explore" | "Plan" | "claude-code-guide" | string;
+/**
+ * Tracked subagent information
+ */
+export interface TrackedSubagent {
+    /** Unique ID for this subagent (same as tool_use_id) */
+    id: string;
+    /** Parent session ID where this subagent was spawned */
+    parentSessionId: string;
+    /** Parent tool use ID if this is a nested subagent */
+    parentToolUseId?: string;
+    /** Type of subagent */
+    subagentType: SubagentType;
+    /** Short description of what the subagent is doing */
+    description: string;
+    /** Full prompt given to the subagent */
+    prompt: string;
+    /** Model used for this subagent (if specified) */
+    model?: "sonnet" | "opus" | "haiku";
+    /** Current status */
+    status: SubagentStatus;
+    /** Timestamp when subagent was created */
+    createdAt: number;
+    /** Timestamp when subagent started running */
+    startedAt?: number;
+    /** Timestamp when subagent completed */
+    completedAt?: number;
+    /** Result from the subagent (if completed) */
+    result?: unknown;
+    /** Error message (if failed) */
+    error?: string;
+    /** Whether this subagent is running in background */
+    runInBackground: boolean;
+    /** Maximum turns allowed */
+    maxTurns?: number;
+    /** Agent ID returned by Claude Code (for resume capability) */
+    agentId?: string;
+}
+/**
+ * Subagent event types for notifications
+ */
+export type SubagentEventType = "subagent_started" | "subagent_progress" | "subagent_completed" | "subagent_failed" | "subagent_cancelled";
+/**
+ * Metadata for subagent-related notifications
+ */
+export interface SubagentUpdateMeta {
+    claudeCode?: {
+        subagent: {
+            id: string;
+            eventType: SubagentEventType;
+            subagentType: SubagentType;
+            description: string;
+            status: SubagentStatus;
+            parentSessionId: string;
+            parentToolUseId?: string;
+            model?: string;
+            runInBackground: boolean;
+            agentId?: string;
+            /** Duration in milliseconds (for completed/failed events) */
+            durationMs?: number;
+        };
+    };
+}
+/**
+ * Input structure for the Task tool
+ */
+export interface TaskToolInput {
+    description: string;
+    prompt: string;
+    subagent_type: SubagentType;
+    model?: "sonnet" | "opus" | "haiku";
+    max_turns?: number;
+    run_in_background?: boolean;
+    resume?: string;
+}
+export type SubagentEventListener = (subagent: TrackedSubagent, data?: unknown) => void | Promise<void>;
+export interface SubagentStats {
+    total: number;
+    pending: number;
+    running: number;
+    completed: number;
+    failed: number;
+    cancelled: number;
+    byType: Record<string, number>;
+    averageDurationMs?: number;
+}
+/**
+ * SubagentTracker manages the lifecycle of all subagents spawned via the Task tool
+ */
+export declare class SubagentTracker {
+    /** Map of subagent ID to tracked subagent data */
+    private subagents;
+    /** Map of session ID to subagent IDs in that session */
+    private sessionSubagents;
+    /** Event listeners for subagent lifecycle events */
+    private listeners;
+    private client;
+    private logger;
+    constructor(client?: AgentSideConnection | null, logger?: Logger);
+    /**
+     * Track a new subagent when Task tool is called
+     */
+    trackSubagent(toolUseId: string, sessionId: string, input: TaskToolInput, parentToolUseId?: string): TrackedSubagent;
+    /**
+     * Mark a subagent as started/running
+     */
+    startSubagent(toolUseId: string): Promise<void>;
+    /**
+     * Mark a subagent as completed successfully
+     */
+    completeSubagent(toolUseId: string, result?: unknown, agentId?: string): Promise<void>;
+    /**
+     * Mark a subagent as failed
+     */
+    failSubagent(toolUseId: string, error: string): Promise<void>;
+    /**
+     * Mark a subagent as cancelled
+     */
+    cancelSubagent(toolUseId: string): Promise<void>;
+    /**
+     * Send progress update for a running subagent
+     */
+    updateProgress(toolUseId: string, progressData?: unknown): Promise<void>;
+    /**
+     * Get a tracked subagent by ID
+     */
+    getSubagent(toolUseId: string): TrackedSubagent | undefined;
+    /**
+     * Get all subagents for a session
+     */
+    getSessionSubagents(sessionId: string): TrackedSubagent[];
+    /**
+     * Get all currently running subagents
+     */
+    getRunningSubagents(): TrackedSubagent[];
+    /**
+     * Get all subagents (for debugging/monitoring)
+     */
+    getAllSubagents(): TrackedSubagent[];
+    /**
+     * Check if a tool use ID is a Task tool (subagent)
+     */
+    isSubagent(toolUseId: string): boolean;
+    /**
+     * Add event listener for subagent lifecycle events
+     */
+    addEventListener(event: SubagentEventType, listener: SubagentEventListener): void;
+    /**
+     * Remove event listener
+     */
+    removeEventListener(event: SubagentEventType, listener: SubagentEventListener): void;
+    /**
+     * Clean up completed subagents older than given age (in ms)
+     */
+    cleanup(maxAgeMs?: number): number;
+    /**
+     * Get statistics about subagents
+     */
+    getStats(): SubagentStats;
+    /**
+     * Clear all tracked subagents (useful for testing)
+     */
+    clear(): void;
+    private emitEvent;
+    private sendSubagentNotification;
+    private getDuration;
+    private countByType;
+    private calculateAverageDuration;
+}
+/**
+ * Utility to check if a tool input is for the Task tool
+ */
+export declare function isTaskToolInput(input: unknown): input is TaskToolInput;
+/**
+ * Extract subagent metadata from Task tool input
+ */
+export declare function extractSubagentMeta(input: TaskToolInput): {
+    description: string;
+    subagentType: string;
+    model?: string;
+    runInBackground: boolean;
+    maxTurns?: number;
+};
+//# sourceMappingURL=subagent-tracker.d.ts.map

package/dist/subagent-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-tracker.d.ts","sourceRoot":"","sources":["../src/subagent-tracker.ts"],"names":[],"mappings":"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"}

package/dist/subagent-tracker.js

@@ -0,0 +1,292 @@
+/**
+ * SubagentTracker manages the lifecycle of all subagents spawned via the Task tool
+ */
+export class SubagentTracker {
+    constructor(client = null, logger = console) {
+        /** Map of subagent ID to tracked subagent data */
+        this.subagents = new Map();
+        /** Map of session ID to subagent IDs in that session */
+        this.sessionSubagents = new Map();
+        /** Event listeners for subagent lifecycle events */
+        this.listeners = new Map();
+        this.client = client;
+        this.logger = logger;
+    }
+    /**
+     * Track a new subagent when Task tool is called
+     */
+    trackSubagent(toolUseId, sessionId, input, parentToolUseId) {
+        const subagent = {
+            id: toolUseId,
+            parentSessionId: sessionId,
+            parentToolUseId,
+            subagentType: input.subagent_type,
+            description: input.description,
+            prompt: input.prompt,
+            model: input.model,
+            status: "pending",
+            createdAt: Date.now(),
+            runInBackground: input.run_in_background ?? false,
+            maxTurns: input.max_turns,
+        };
+        this.subagents.set(toolUseId, subagent);
+        // Track by session
+        if (!this.sessionSubagents.has(sessionId)) {
+            this.sessionSubagents.set(sessionId, new Set());
+        }
+        this.sessionSubagents.get(sessionId).add(toolUseId);
+        this.logger.log(`[SubagentTracker] Tracked new subagent: ${toolUseId} (${input.subagent_type}: ${input.description})`);
+        return subagent;
+    }
+    /**
+     * Mark a subagent as started/running
+     */
+    async startSubagent(toolUseId) {
+        const subagent = this.subagents.get(toolUseId);
+        if (!subagent) {
+            this.logger.error(`[SubagentTracker] Cannot start unknown subagent: ${toolUseId}`);
+            return;
+        }
+        subagent.status = "running";
+        subagent.startedAt = Date.now();
+        await this.emitEvent("subagent_started", subagent);
+        await this.sendSubagentNotification(subagent, "subagent_started");
+    }
+    /**
+     * Mark a subagent as completed successfully
+     */
+    async completeSubagent(toolUseId, result, agentId) {
+        const subagent = this.subagents.get(toolUseId);
+        if (!subagent) {
+            this.logger.error(`[SubagentTracker] Cannot complete unknown subagent: ${toolUseId}`);
+            return;
+        }
+        subagent.status = "completed";
+        subagent.completedAt = Date.now();
+        subagent.result = result;
+        if (agentId) {
+            subagent.agentId = agentId;
+        }
+        await this.emitEvent("subagent_completed", subagent);
+        await this.sendSubagentNotification(subagent, "subagent_completed");
+        this.logger.log(`[SubagentTracker] Subagent completed: ${toolUseId} (duration: ${this.getDuration(subagent)}ms)`);
+    }
+    /**
+     * Mark a subagent as failed
+     */
+    async failSubagent(toolUseId, error) {
+        const subagent = this.subagents.get(toolUseId);
+        if (!subagent) {
+            this.logger.error(`[SubagentTracker] Cannot fail unknown subagent: ${toolUseId}`);
+            return;
+        }
+        subagent.status = "failed";
+        subagent.completedAt = Date.now();
+        subagent.error = error;
+        await this.emitEvent("subagent_failed", subagent);
+        await this.sendSubagentNotification(subagent, "subagent_failed");
+        this.logger.error(`[SubagentTracker] Subagent failed: ${toolUseId} - ${error}`);
+    }
+    /**
+     * Mark a subagent as cancelled
+     */
+    async cancelSubagent(toolUseId) {
+        const subagent = this.subagents.get(toolUseId);
+        if (!subagent) {
+            return; // Silent fail for cancel - may not be tracked
+        }
+        subagent.status = "cancelled";
+        subagent.completedAt = Date.now();
+        await this.emitEvent("subagent_cancelled", subagent);
+        await this.sendSubagentNotification(subagent, "subagent_cancelled");
+        this.logger.log(`[SubagentTracker] Subagent cancelled: ${toolUseId}`);
+    }
+    /**
+     * Send progress update for a running subagent
+     */
+    async updateProgress(toolUseId, progressData) {
+        const subagent = this.subagents.get(toolUseId);
+        if (!subagent || subagent.status !== "running") {
+            return;
+        }
+        await this.emitEvent("subagent_progress", subagent, progressData);
+        await this.sendSubagentNotification(subagent, "subagent_progress");
+    }
+    /**
+     * Get a tracked subagent by ID
+     */
+    getSubagent(toolUseId) {
+        return this.subagents.get(toolUseId);
+    }
+    /**
+     * Get all subagents for a session
+     */
+    getSessionSubagents(sessionId) {
+        const ids = this.sessionSubagents.get(sessionId);
+        if (!ids)
+            return [];
+        return Array.from(ids)
+            .map((id) => this.subagents.get(id))
+            .filter((s) => s !== undefined);
+    }
+    /**
+     * Get all currently running subagents
+     */
+    getRunningSubagents() {
+        return Array.from(this.subagents.values()).filter((s) => s.status === "running");
+    }
+    /**
+     * Get all subagents (for debugging/monitoring)
+     */
+    getAllSubagents() {
+        return Array.from(this.subagents.values());
+    }
+    /**
+     * Check if a tool use ID is a Task tool (subagent)
+     */
+    isSubagent(toolUseId) {
+        return this.subagents.has(toolUseId);
+    }
+    /**
+     * Add event listener for subagent lifecycle events
+     */
+    addEventListener(event, listener) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(listener);
+    }
+    /**
+     * Remove event listener
+     */
+    removeEventListener(event, listener) {
+        this.listeners.get(event)?.delete(listener);
+    }
+    /**
+     * Clean up completed subagents older than given age (in ms)
+     */
+    cleanup(maxAgeMs = 3600000) {
+        const now = Date.now();
+        let cleanedCount = 0;
+        for (const [id, subagent] of this.subagents) {
+            if ((subagent.status === "completed" ||
+                subagent.status === "failed" ||
+                subagent.status === "cancelled") &&
+                subagent.completedAt &&
+                now - subagent.completedAt > maxAgeMs) {
+                this.subagents.delete(id);
+                this.sessionSubagents.get(subagent.parentSessionId)?.delete(id);
+                cleanedCount++;
+            }
+        }
+        return cleanedCount;
+    }
+    /**
+     * Get statistics about subagents
+     */
+    getStats() {
+        const subagents = Array.from(this.subagents.values());
+        return {
+            total: subagents.length,
+            pending: subagents.filter((s) => s.status === "pending").length,
+            running: subagents.filter((s) => s.status === "running").length,
+            completed: subagents.filter((s) => s.status === "completed").length,
+            failed: subagents.filter((s) => s.status === "failed").length,
+            cancelled: subagents.filter((s) => s.status === "cancelled").length,
+            byType: this.countByType(subagents),
+            averageDurationMs: this.calculateAverageDuration(subagents),
+        };
+    }
+    /**
+     * Clear all tracked subagents (useful for testing)
+     */
+    clear() {
+        this.subagents.clear();
+        this.sessionSubagents.clear();
+    }
+    // Private helper methods
+    async emitEvent(event, subagent, data) {
+        const listeners = this.listeners.get(event);
+        if (!listeners)
+            return;
+        for (const listener of listeners) {
+            try {
+                await listener(subagent, data);
+            }
+            catch (err) {
+                this.logger.error(`[SubagentTracker] Error in event listener:`, err);
+            }
+        }
+    }
+    async sendSubagentNotification(subagent, eventType) {
+        if (!this.client)
+            return;
+        const notification = {
+            sessionId: subagent.parentSessionId,
+            update: {
+                sessionUpdate: "tool_call_update",
+                toolCallId: subagent.id,
+                _meta: {
+                    claudeCode: {
+                        subagent: {
+                            id: subagent.id,
+                            eventType,
+                            subagentType: subagent.subagentType,
+                            description: subagent.description,
+                            status: subagent.status,
+                            parentSessionId: subagent.parentSessionId,
+                            parentToolUseId: subagent.parentToolUseId,
+                            model: subagent.model,
+                            runInBackground: subagent.runInBackground,
+                            agentId: subagent.agentId,
+                            durationMs: this.getDuration(subagent),
+                        },
+                    },
+                },
+            },
+        };
+        await this.client.sessionUpdate(notification);
+    }
+    getDuration(subagent) {
+        if (!subagent.startedAt)
+            return undefined;
+        const endTime = subagent.completedAt ?? Date.now();
+        return endTime - subagent.startedAt;
+    }
+    countByType(subagents) {
+        const counts = {};
+        for (const s of subagents) {
+            counts[s.subagentType] = (counts[s.subagentType] || 0) + 1;
+        }
+        return counts;
+    }
+    calculateAverageDuration(subagents) {
+        const completed = subagents.filter((s) => (s.status === "completed" || s.status === "failed") && s.startedAt && s.completedAt);
+        if (completed.length === 0)
+            return undefined;
+        const totalDuration = completed.reduce((sum, s) => sum + (s.completedAt - s.startedAt), 0);
+        return Math.round(totalDuration / completed.length);
+    }
+}
+/**
+ * Utility to check if a tool input is for the Task tool
+ */
+export function isTaskToolInput(input) {
+    return (typeof input === "object" &&
+        input !== null &&
+        "prompt" in input &&
+        "subagent_type" in input &&
+        "description" in input);
+}
+/**
+ * Extract subagent metadata from Task tool input
+ */
+export function extractSubagentMeta(input) {
+    return {
+        description: input.description,
+        subagentType: input.subagent_type,
+        model: input.model,
+        runInBackground: input.run_in_background ?? false,
+        maxTurns: input.max_turns,
+    };
+}

package/dist/tools.d.ts

@@ -0,0 +1,50 @@
+import { PlanEntry, ToolCallContent, ToolCallLocation, ToolKind } from "@agentclientprotocol/sdk";
+import { ToolResultBlockParam, WebSearchToolResultBlockParam } from "@anthropic-ai/sdk/resources";
+export declare const ACP_TOOL_NAME_PREFIX = "mcp__acp__";
+export declare const acpToolNames: {
+    read: string;
+    edit: string;
+    write: string;
+    bash: string;
+    killShell: string;
+    bashOutput: string;
+};
+export declare const EDIT_TOOL_NAMES: string[];
+import { BetaBashCodeExecutionToolResultBlockParam, BetaCodeExecutionToolResultBlockParam, BetaRequestMCPToolResultBlockParam, BetaTextEditorCodeExecutionToolResultBlockParam, BetaToolSearchToolResultBlockParam, BetaWebFetchToolResultBlockParam, BetaWebSearchToolResultBlockParam } from "@anthropic-ai/sdk/resources/beta.mjs";
+import { HookCallback } from "@anthropic-ai/claude-agent-sdk";
+import { Logger } from "./acp-agent.js";
+import { SettingsManager } from "./settings.js";
+interface ToolInfo {
+    title: string;
+    kind: ToolKind;
+    content: ToolCallContent[];
+    locations?: ToolCallLocation[];
+}
+interface ToolUpdate {
+    title?: string;
+    content?: ToolCallContent[];
+    locations?: ToolCallLocation[];
+}
+export declare function toolInfoFromToolUse(toolUse: any): ToolInfo;
+export declare function toolUpdateFromToolResult(toolResult: ToolResultBlockParam | BetaWebSearchToolResultBlockParam | BetaWebFetchToolResultBlockParam | WebSearchToolResultBlockParam | BetaCodeExecutionToolResultBlockParam | BetaBashCodeExecutionToolResultBlockParam | BetaTextEditorCodeExecutionToolResultBlockParam | BetaRequestMCPToolResultBlockParam | BetaToolSearchToolResultBlockParam, toolUse: any | undefined): ToolUpdate;
+export type ClaudePlanEntry = {
+    content: string;
+    status: "pending" | "in_progress" | "completed";
+    activeForm: string;
+};
+export declare function planEntries(input: {
+    todos: ClaudePlanEntry[];
+}): PlanEntry[];
+export declare function markdownEscape(text: string): string;
+export declare const registerHookCallback: (toolUseID: string, { onPostToolUseHook, }: {
+    onPostToolUseHook?: (toolUseID: string, toolInput: unknown, toolResponse: unknown) => Promise<void>;
+}) => void;
+export declare const createPostToolUseHook: (logger?: Logger) => HookCallback;
+/**
+ * Creates a PreToolUse hook that checks permissions using the SettingsManager.
+ * This runs before the SDK's built-in permission rules, allowing us to enforce
+ * our own permission settings for ACP-prefixed tools.
+ */
+export declare const createPreToolUseHook: (settingsManager: SettingsManager, logger?: Logger) => HookCallback;
+export {};
+//# sourceMappingURL=tools.d.ts.map

package/dist/tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../src/tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGlG,OAAO,EAAE,oBAAoB,EAAE,6BAA6B,EAAE,MAAM,6BAA6B,CAAC;AAWlG,eAAO,MAAM,oBAAoB,eAAe,CAAC;AACjD,eAAO,MAAM,YAAY;;;;;;;CAOxB,CAAC;AAEF,eAAO,MAAM,eAAe,UAA0C,CAAC;AAEvE,OAAO,EACL,yCAAyC,EACzC,qCAAqC,EACrC,kCAAkC,EAClC,+CAA+C,EAC/C,kCAAkC,EAClC,gCAAgC,EAChC,iCAAiC,EAClC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAEhD,UAAU,QAAQ;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,UAAU,UAAU;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,eAAe,EAAE,CAAC;IAC5B,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;CAChC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,GAAG,GAAG,QAAQ,CA+V1D;AAED,wBAAgB,wBAAwB,CACtC,UAAU,EACN,oBAAoB,GACpB,iCAAiC,GACjC,gCAAgC,GAChC,6BAA6B,GAC7B,qCAAqC,GACrC,yCAAyC,GACzC,+CAA+C,GAC/C,kCAAkC,GAClC,kCAAkC,EACtC,OAAO,EAAE,GAAG,GAAG,SAAS,GACvB,UAAU,CA4HZ;AAmCD,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,SAAS,GAAG,aAAa,GAAG,WAAW,CAAC;IAChD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,wBAAgB,WAAW,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,eAAe,EAAE,CAAA;CAAE,GAAG,SAAS,EAAE,CAM5E;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQnD;AAcD,eAAO,MAAM,oBAAoB,GAC/B,WAAW,MAAM,EACjB,wBAEG;IACD,iBAAiB,CAAC,EAAE,CAClB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,OAAO,EAClB,YAAY,EAAE,OAAO,KAClB,OAAO,CAAC,IAAI,CAAC,CAAC;CACpB,SAKF,CAAC;AAGF,eAAO,MAAM,qBAAqB,GAC/B,SAAQ,MAAgB,KAAG,YAa3B,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAC9B,iBAAiB,eAAe,EAAE,SAAQ,MAAgB,KAAG,YA2C7D,CAAC"}