codeep 1.2.74 → 1.2.75

package/README.md

@@ -681,7 +681,7 @@ With write access enabled:
 | Agent Mode | ON | `ON` = agent runs automatically (requires write permission via `/grant`), `Manual` = use /agent |
 | Agent API Timeout | 180000ms | Timeout per agent API call (auto-adjusted for complexity) |
 | Agent Max Duration | 20 min | Maximum time for agent to run (5-60 min) |
-| Agent Max Iterations | 100 | Maximum agent iterations (10-200) |
+| Agent Max Iterations | 200 | Maximum agent iterations (10-500) |
 | Agent Confirmation | Dangerous | `Never`, `Dangerous` (default), or `Always` |
 | Agent Auto-Commit | Off | Automatically commit after agent completes |
 | Agent Branch | Off | Create new branch for agent commits |

package/dist/acp/protocol.d.ts

@@ -34,6 +34,7 @@ export interface InitializeParams {
 }
 export interface AgentCapabilities {
     loadSession?: boolean;
+    terminal?: boolean;
     promptCapabilities?: {
         image?: boolean;
         audio?: boolean;
@@ -174,7 +175,17 @@ export interface SessionUpdateSessionInfo {
     title: string;
     updatedAt?: string;
 }
-export type SessionUpdateInner = SessionUpdateAgentMessageChunk | SessionUpdateAgentThoughtChunk | SessionUpdateToolCall | SessionUpdateToolCallUpdate | SessionUpdateAvailableCommands | SessionUpdateCurrentMode | SessionUpdateConfigOption | SessionUpdateSessionInfo;
+export interface PlanEntry {
+    id: string;
+    content: string;
+    priority: 'high' | 'medium' | 'low';
+    status: 'pending' | 'in_progress' | 'completed';
+}
+export interface SessionUpdatePlan {
+    sessionUpdate: 'plan';
+    entries: PlanEntry[];
+}
+export type SessionUpdateInner = SessionUpdateAgentMessageChunk | SessionUpdateAgentThoughtChunk | SessionUpdateToolCall | SessionUpdateToolCallUpdate | SessionUpdatePlan | SessionUpdateAvailableCommands | SessionUpdateCurrentMode | SessionUpdateConfigOption | SessionUpdateSessionInfo;
 export interface SessionUpdateParams {
     sessionId: string;
     update: SessionUpdateInner;
@@ -237,4 +248,46 @@ export interface FsWriteTextFileParams {
     path: string;
     content: string;
 }
+export interface TerminalCreateParams {
+    sessionId: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    env?: Record<string, string>;
+    outputByteLimit?: number;
+}
+export interface TerminalCreateResult {
+    terminalId: string;
+}
+export interface TerminalWaitForExitParams {
+    sessionId: string;
+    terminalId: string;
+    timeoutMs?: number;
+}
+export type TerminalExitStatus = {
+    type: 'exited';
+    code: number;
+} | {
+    type: 'killed';
+    signal?: string;
+};
+export interface TerminalWaitForExitResult {
+    exitStatus: TerminalExitStatus;
+}
+export interface TerminalOutputParams {
+    sessionId: string;
+    terminalId: string;
+    offset?: number;
+}
+export interface TerminalOutputResult {
+    output: string;
+    /** Absent while the process is still running; present once the process has exited. */
+    exitStatus?: TerminalExitStatus;
+}
+export interface TerminalReleaseParams {
+    sessionId: string;
+    terminalId: string;
+}
+export interface TerminalReleaseResult {
+}
 export type AcpMessage = JsonRpcRequest | JsonRpcResponse | JsonRpcNotification;

package/dist/acp/server.js

@@ -4,6 +4,7 @@ import { randomUUID } from 'crypto';
 import { basename as pathBasename } from 'path';
 import { StdioTransport } from './transport.js';
 import { runAgentSession } from './session.js';
+import { executeCommandAsync } from '../utils/shell.js';
 import { initWorkspace, loadWorkspace, handleCommand } from './commands.js';
 import { autoSaveSession, config, setProvider, listSessionsWithInfo, deleteSession as deleteSessionFile } from '../config/index.js';
 import { PROVIDERS } from '../config/providers.js';
@@ -165,6 +166,7 @@ export function startAcpServer() {
             protocolVersion: 1,
             agentCapabilities: {
                 loadSession: true,
+                terminal: true,
                 sessionCapabilities: { list: {} },
             },
             agentInfo: {
@@ -381,6 +383,18 @@ export function startAcpServer() {
             .join('\n');
         const abortController = new AbortController();
         session.abortController = abortController;
+        // Plan tracking: build a live plan from tool calls as the agent works
+        // ACP spec: send complete list on every update, client replaces current plan
+        const planEntries = new Map();
+        const sendPlan = () => {
+            transport.notify('session/update', {
+                sessionId: params.sessionId,
+                update: {
+                    sessionUpdate: 'plan',
+                    entries: [...planEntries.values()],
+                },
+            });
+        };
         const agentResponseChunks = [];
         const sendChunk = (text) => {
             agentResponseChunks.push(text);
@@ -456,6 +470,16 @@ export function startAcpServer() {
                                     : {}),
                             },
                         });
+                        // Add to plan as in_progress — only meaningful actions (not reads)
+                        if (kind === 'edit' || kind === 'execute' || kind === 'delete') {
+                            planEntries.set(toolCallId, {
+                                id: toolCallId,
+                                content: title || toolName,
+                                priority: kind === 'execute' ? 'high' : 'medium',
+                                status: 'in_progress',
+                            });
+                            sendPlan();
+                        }
                     }
                     else {
                         // tool_call_update: update status to completed/failed, with optional content
@@ -468,6 +492,70 @@ export function startAcpServer() {
                                 ...(rawOutput !== undefined ? { rawOutput } : {}),
                             },
                         });
+                        // Mark plan entry as completed
+                        const entry = planEntries.get(toolCallId);
+                        if (entry) {
+                            entry.status = 'completed';
+                            sendPlan();
+                        }
+                    }
+                },
+                // Only request permission in Manual mode
+                onRequestPermission: session.currentModeId === 'manual'
+                    ? async (toolCall) => {
+                        const permToolCallId = `perm_${randomUUID()}`;
+                        const result = await transport.request('session/request_permission', {
+                            sessionId: params.sessionId,
+                            toolCall: {
+                                toolCallId: permToolCallId,
+                                toolName: toolCall.tool,
+                                toolInput: toolCall.parameters,
+                                status: 'pending',
+                                content: [],
+                            },
+                            options: [
+                                { optionId: 'allow_once', name: 'Allow once', kind: 'allow_once' },
+                                { optionId: 'allow_always', name: 'Allow always', kind: 'allow_always' },
+                                { optionId: 'reject_once', name: 'Reject once', kind: 'reject_once' },
+                                { optionId: 'reject_always', name: 'Reject always', kind: 'reject_always' },
+                            ],
+                        });
+                        // Map ACP outcome back to PermissionOutcome
+                        if (!result || result.outcome.type === 'cancelled')
+                            return 'reject_once';
+                        return result.outcome.optionId;
+                    }
+                    : undefined,
+                onExecuteCommand: async (command, args, cwd) => {
+                    try {
+                        const createResult = await transport.request('terminal/create', {
+                            sessionId: params.sessionId,
+                            command,
+                            args,
+                            cwd,
+                            outputByteLimit: 1_000_000,
+                        });
+                        const { terminalId } = createResult;
+                        const waitResult = await transport.request('terminal/waitForExit', {
+                            sessionId: params.sessionId,
+                            terminalId,
+                            timeoutMs: 120_000,
+                        });
+                        const outputResult = await transport.request('terminal/output', {
+                            sessionId: params.sessionId,
+                            terminalId,
+                        });
+                        await transport.request('terminal/release', {
+                            sessionId: params.sessionId,
+                            terminalId,
+                        });
+                        const exitCode = waitResult.exitStatus.type === 'exited' ? waitResult.exitStatus.code : 1;
+                        return { stdout: outputResult.output ?? '', stderr: '', exitCode };
+                    }
+                    catch (err) {
+                        // Zed terminal unavailable — fall back to local execution
+                        const r = await executeCommandAsync(command, args, { cwd, projectRoot: cwd, timeout: 120000 });
+                        return { stdout: r.stdout ?? '', stderr: r.stderr ?? '', exitCode: r.exitCode ?? 0 };
                     }
                 },
             }).then(() => {

package/dist/acp/session.d.ts

@@ -1,4 +1,6 @@
+import { PermissionOutcome } from '../utils/agent.js';
 import { ProjectContext } from '../utils/project.js';
+import { ToolCall } from '../utils/tools.js';
 export interface AgentSessionOptions {
     prompt: string;
     workspaceRoot: string;
@@ -7,6 +9,12 @@ export interface AgentSessionOptions {
     onChunk: (text: string) => void;
     onThought?: (text: string) => void;
     onToolCall?: (toolCallId: string, toolName: string, kind: string, title: string, status: 'pending' | 'running' | 'finished' | 'error', locations?: string[], rawOutput?: string) => void;
+    onRequestPermission?: (toolCall: ToolCall) => Promise<PermissionOutcome>;
+    onExecuteCommand?: (command: string, args: string[], cwd: string) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
 }
 /**
  * Build a ProjectContext from a workspace root directory.

package/dist/acp/session.js

@@ -140,6 +140,8 @@ export async function runAgentSession(opts) {
                 toolCallIdMap.delete(mapKey);
             }
         },
+        onRequestPermission: opts.onRequestPermission,
+        onExecuteCommand: opts.onExecuteCommand,
     });
     // result.finalResponse is already emitted via onChunk streaming above;
     // only emit it here if nothing was streamed (e.g. non-streaming fallback path)

package/dist/acp/transport.d.ts

@@ -3,11 +3,18 @@ type MessageHandler = (msg: JsonRpcRequest | JsonRpcNotification) => void;
 export declare class StdioTransport {
     private buffer;
     private handler;
+    private pendingRequests;
+    private requestIdCounter;
     start(handler: MessageHandler): void;
     private onData;
     send(msg: JsonRpcResponse | JsonRpcNotification): void;
     respond(id: number | string, result: unknown): void;
     error(id: number | string, code: number, message: string): void;
     notify(method: string, params: unknown): void;
+    /**
+     * Send a JSON-RPC request to the client and wait for the response.
+     * Used for agent-initiated requests like session/request_permission.
+     */
+    request(method: string, params: unknown): Promise<unknown>;
 }
 export {};

package/dist/acp/transport.js

@@ -3,6 +3,8 @@
 export class StdioTransport {
     buffer = '';
     handler = null;
+    pendingRequests = new Map();
+    requestIdCounter = 1000;
     start(handler) {
         this.handler = handler;
         process.stdin.setEncoding('utf8');
@@ -19,6 +21,16 @@ export class StdioTransport {
                 continue;
             try {
                 const msg = JSON.parse(trimmed);
+                // Check if this is a response to one of our outbound requests
+                if ('result' in msg || 'error' in msg) {
+                    const response = msg;
+                    const resolve = this.pendingRequests.get(response.id);
+                    if (resolve) {
+                        this.pendingRequests.delete(response.id);
+                        resolve(response.result ?? null);
+                        continue;
+                    }
+                }
                 this.handler?.(msg);
             }
             catch {
@@ -38,4 +50,15 @@ export class StdioTransport {
     notify(method, params) {
         this.send({ jsonrpc: '2.0', method, params });
     }
+    /**
+     * Send a JSON-RPC request to the client and wait for the response.
+     * Used for agent-initiated requests like session/request_permission.
+     */
+    request(method, params) {
+        const id = ++this.requestIdCounter;
+        return new Promise((resolve) => {
+            this.pendingRequests.set(id, resolve);
+            process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+        });
+    }
 }

package/dist/config/index.js

@@ -148,7 +148,7 @@ function createConfig() {
         agentAutoCommitBranch: false,
         agentAutoVerify: 'off',
         agentMaxFixAttempts: 3,
-        agentMaxIterations: 100,
+        agentMaxIterations: 200,
         agentMaxDuration: 20,
         agentApiTimeout: 180000,
         protocol: 'openai',

package/dist/renderer/components/Settings.js

@@ -109,7 +109,7 @@ export const SETTINGS = [
         getValue: () => config.get('agentMaxIterations'),
         type: 'number',
         min: 10,
-        max: 200,
+        max: 500,
         step: 10,
     },
     {

package/dist/utils/agent.d.ts

@@ -12,6 +12,7 @@ import { ToolCall, ToolResult, ActionLog } from './tools';
 import { undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession, ActionSession } from './history';
 import { VerifyResult } from './verify';
 import { TaskPlan, SubTask } from './taskPlanner';
+export type PermissionOutcome = 'allow_once' | 'allow_always' | 'reject_once' | 'reject_always';
 export interface AgentOptions {
     maxIterations: number;
     maxDuration: number;
@@ -23,6 +24,12 @@ export interface AgentOptions {
     onVerification?: (results: VerifyResult[]) => void;
     onTaskPlan?: (plan: TaskPlan) => void;
     onTaskUpdate?: (task: SubTask) => void;
+    onRequestPermission?: (toolCall: ToolCall) => Promise<PermissionOutcome>;
+    onExecuteCommand?: (command: string, args: string[], cwd: string) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
     abortSignal?: AbortSignal;
     dryRun?: boolean;
     autoVerify?: 'off' | 'build' | 'typecheck' | 'test' | 'all' | boolean;

package/dist/utils/agent.js

@@ -176,6 +176,10 @@ export async function runAgent(prompt, projectContext, options = {}) {
     let consecutiveTimeouts = 0;
     let incompleteWorkRetries = 0;
     const maxIncompleteWorkRetries = 2;
+    // Track tools permanently allowed this session via allow_always
+    const alwaysAllowedTools = new Set();
+    // Tools that require permission when onRequestPermission is set
+    const dangerousTools = new Set(['delete_file', 'execute_command']);
     const maxTimeoutRetries = 3;
     const maxConsecutiveTimeouts = 9; // Allow more consecutive timeouts before giving up
     const baseTimeout = config.get('agentApiTimeout');
@@ -376,9 +380,28 @@ export async function runAgent(prompt, projectContext, options = {}) {
             const toolResults = [];
             for (const toolCall of toolCalls) {
                 opts.onToolCall?.(toolCall);
+                // Permission check for dangerous tools (only when callback is provided, e.g. ACP/Zed)
+                if (opts.onRequestPermission && dangerousTools.has(toolCall.tool) && !alwaysAllowedTools.has(toolCall.tool)) {
+                    const outcome = await opts.onRequestPermission(toolCall);
+                    if (outcome === 'allow_always') {
+                        alwaysAllowedTools.add(toolCall.tool);
+                    }
+                    else if (outcome === 'reject_once' || outcome === 'reject_always') {
+                        const toolResult = {
+                            success: false,
+                            output: '',
+                            error: `User rejected permission for ${toolCall.tool}`,
+                            tool: toolCall.tool,
+                            parameters: toolCall.parameters,
+                        };
+                        opts.onToolResult?.(toolResult, toolCall);
+                        actions.push(createActionLog(toolCall, toolResult));
+                        toolResults.push(`Tool ${toolCall.tool} was rejected by user.`);
+                        continue;
+                    }
+                }
                 let toolResult;
                 if (opts.dryRun) {
-                    // In dry run mode, simulate success
                     toolResult = {
                         success: true,
                         output: `[DRY RUN] Would execute: ${toolCall.tool}`,
@@ -386,8 +409,40 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         parameters: toolCall.parameters,
                     };
                 }
+                else if (opts.onExecuteCommand && toolCall.tool === 'execute_command') {
+                    // Delegate to external terminal (e.g. Zed ACP terminal)
+                    // Note: onExecuteCommand runs after the permission gate above
+                    const command = toolCall.parameters.command;
+                    const args = toolCall.parameters.args || [];
+                    const cwd = projectContext.root || process.cwd();
+                    if (!command) {
+                        toolResult = {
+                            success: false,
+                            output: '',
+                            error: 'execute_command called with missing command field',
+                            tool: toolCall.tool,
+                            parameters: toolCall.parameters,
+                        };
+                    }
+                    else {
+                        try {
+                            const commandResult = await opts.onExecuteCommand(command, args, cwd);
+                            toolResult = {
+                                success: commandResult.exitCode === 0,
+                                output: commandResult.stdout || '(no output)',
+                                error: commandResult.exitCode !== 0 ? (commandResult.stderr || `exited with code ${commandResult.exitCode}`) : undefined,
+                                tool: toolCall.tool,
+                                parameters: toolCall.parameters,
+                            };
+                        }
+                        catch (err) {
+                            debug('onExecuteCommand callback threw, falling back to local execution:', err);
+                            // Fallback to local execution if callback throws
+                            toolResult = await executeTool(toolCall, cwd);
+                        }
+                    }
+                }
                 else {
-                    // Actually execute the tool
                     toolResult = await executeTool(toolCall, projectContext.root || process.cwd());
                 }
                 opts.onToolResult?.(toolResult, toolCall);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.2.74",
+  "version": "1.2.75",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",