@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/handlers/permission-handler.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Permission handler factory — extracted from index.ts.
+ *
+ * Creates the `onPermissionRequest` callback consumed by the agent.
+ * The deps object is SharedState passed by reference, so live mutations
+ * (e.g. vsDiffEnabled toggled off mid-session) work exactly as before.
+ */
+import type { PermissionResult, PermissionOverlayV2Options } from '../ui/overlay/impl/permission-overlay-v2.js';
+import type { AgentMode } from '../ui/types.js';
+export interface PermissionHandlerDeps {
+    mode: AgentMode;
+    flushTextBuffer?: () => void;
+    showPermissionOverlayV2?: (options: PermissionOverlayV2Options) => Promise<PermissionResult | null>;
+    grantSession?: (toolName: string) => void;
+    setMode?: (mode: AgentMode) => void;
+    getActiveBackgroundAgentId?: () => string | null;
+    isBackgroundAgent?: (id: string) => boolean;
+    getBackgroundAgentInfo?: (id: string) => {
+        mascot: string;
+    } | null;
+    vsDiffEnabled: boolean;
+    vsDiffExtensionChecked: boolean;
+    sessionPrefix: string;
+}
+export declare function createPermissionHandler(deps: PermissionHandlerDeps): (request: {
+    toolName: string;
+    input: Record<string, unknown>;
+    level: string;
+    description?: string;
+}) => Promise<boolean>;

package/dist/handlers/permission-handler.js

@@ -0,0 +1,205 @@
+/**
+ * Permission handler factory — extracted from index.ts.
+ *
+ * Creates the `onPermissionRequest` callback consumed by the agent.
+ * The deps object is SharedState passed by reference, so live mutations
+ * (e.g. vsDiffEnabled toggled off mid-session) work exactly as before.
+ */
+import { getPermissionMode, findMatchingRule } from '../settings/index.js';
+import { getPendingRequestsManager } from '../multi-agent/index.js';
+import * as diff from '../ui/diff.js';
+import { getStyles } from '../themes/index.js';
+import { ensureExtensionInstalled } from '../utils/vscode-detect.js';
+import { openVSCodeDiffForTool, waitForDiffResponse, cancelDiffRequest, } from '../ui/vscode-diff-ipc.js';
+import chalk from 'chalk';
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+export function createPermissionHandler(deps) {
+    return async (request) => {
+        // Auto-accept mode: allow everything without prompting (set via "Always allow" in permission prompt)
+        if (deps.mode === 'auto-accept') {
+            return true;
+        }
+        // Check the global permission mode first
+        const permissionMode = getPermissionMode();
+        // "Auto-accept" mode: allow everything
+        if (permissionMode === 'auto-accept') {
+            return true;
+        }
+        // "Plan" mode: always prompt (no auto-approval based on rules)
+        // "Default" mode: use rule-based checking
+        // Check custom permission rules (for non-plan mode)
+        if (permissionMode !== 'plan') {
+            const rule = findMatchingRule(request.toolName);
+            if (rule) {
+                if (rule.level === 'always') {
+                    return true;
+                }
+                if (rule.level === 'deny') {
+                    return false;
+                }
+                // 'session' and 'once' levels still need prompting (handled below)
+            }
+        }
+        // Phase 3b: Background agent permission handling
+        // If this request comes from a background agent, enqueue it instead of showing overlay
+        const backgroundAgentId = deps.getActiveBackgroundAgentId?.();
+        if (backgroundAgentId && deps.isBackgroundAgent?.(backgroundAgentId)) {
+            const agentInfo = deps.getBackgroundAgentInfo?.(backgroundAgentId);
+            const pendingManager = getPendingRequestsManager();
+            // Build prompt for the pending request
+            const prompt = `${request.toolName}: ${request.description ?? JSON.stringify(request.input).slice(0, 100)}`;
+            try {
+                const response = await pendingManager.enqueue({
+                    agentId: backgroundAgentId,
+                    mascot: agentInfo?.mascot ?? '[•_•]',
+                    type: 'permission',
+                    prompt,
+                    context: {
+                        toolName: request.toolName,
+                        input: request.input,
+                        description: request.description,
+                    },
+                });
+                // Handle response
+                if (response.approved) {
+                    // If user approved with "always allow", grant session permission
+                    if (response.responseText === 'always') {
+                        deps.grantSession?.(request.toolName);
+                    }
+                    return true;
+                }
+                return false;
+            }
+            catch {
+                // Request was cancelled (agent killed, etc.)
+                return false;
+            }
+        }
+        // Flush any accumulated text BEFORE showing the permission overlay
+        // This ensures agent's "I'll help you..." text appears before the permission prompt
+        deps.flushTextBuffer?.();
+        // Extract edit parameters (hoisted for VS Code diff access)
+        let filePath = '';
+        let oldText = '';
+        let newText = '';
+        let replaceAll = false;
+        if (request.toolName === 'edit') {
+            filePath = ((typeof request.input.filePath === 'string' ? request.input.filePath : null) ||
+                (typeof request.input.file_path === 'string' ? request.input.file_path : null) ||
+                (typeof request.input.path === 'string' ? request.input.path : null) || '');
+            oldText = ((typeof request.input.oldString === 'string' ? request.input.oldString : null) ||
+                (typeof request.input.old_string === 'string' ? request.input.old_string : null) ||
+                (typeof request.input.old_text === 'string' ? request.input.old_text : null) || '');
+            newText = ((typeof request.input.newString === 'string' ? request.input.newString : null) ||
+                (typeof request.input.new_string === 'string' ? request.input.new_string : null) ||
+                (typeof request.input.new_text === 'string' ? request.input.new_text : null) || '');
+            replaceAll = Boolean(request.input.replaceAll);
+        }
+        // For edit/write operations, pre-render diff lines for the overlay
+        let diffLines;
+        if (request.toolName === 'edit') {
+            if (filePath && oldText && newText) {
+                const editDiff = diff.generateEditDiff(filePath, oldText, newText, replaceAll);
+                if (editDiff) {
+                    const s = getStyles();
+                    diffLines = [
+                        s.warning('● ') + chalk.bold(`Edit(${filePath.split('/').pop() ?? 'unknown'})`),
+                        diff.formatDiffHeader(filePath, editDiff.additions, editDiff.removals),
+                        ...editDiff.lines,
+                    ];
+                }
+            }
+        }
+        else if (request.toolName === 'write_file' || request.toolName === 'write') {
+            const writePath = typeof request.input.path === 'string' ? request.input.path : '';
+            const writeContent = typeof request.input.content === 'string' ? request.input.content : '';
+            if (writePath && writeContent) {
+                const writeDiff = diff.generateWriteDiff(writePath, writeContent, true);
+                const s = getStyles();
+                diffLines = [
+                    s.warning('● ') + chalk.bold(`Write(${writePath.split('/').pop() ?? 'unknown'})`),
+                    diff.formatWriteHeader(writePath, writeContent.split('\n').length, true),
+                    ...writeDiff.lines,
+                ];
+            }
+        }
+        // VS Code diff: send diff request if enabled and this is an edit/write
+        let vsDiffRequestId = null;
+        if (deps.vsDiffEnabled && (request.toolName === 'edit' || request.toolName === 'write_file' || request.toolName === 'write')) {
+            // Ensure extension is installed (first time only, handles version upgrades)
+            if (!deps.vsDiffExtensionChecked) {
+                deps.vsDiffExtensionChecked = true;
+                const installResult = await ensureExtensionInstalled();
+                if (installResult.needsReload) {
+                    // Extension was just installed — needs VS Code reload to activate.
+                    // Skip VS Code diff for this session; it'll work after reload.
+                    deps.vsDiffEnabled = false;
+                    process.stderr.write('\n  \x1b[33m⚠ VS Code diff extension installed.\x1b[0m\n' +
+                        '  \x1b[2mReload VS Code window (Ctrl+Shift+P → "Developer: Reload Window") to activate.\x1b[0m\n' +
+                        '  \x1b[2mDiff view will be available after reload.\x1b[0m\n\n');
+                }
+                else if (!installResult.installed) {
+                    // Install failed — disable for this session
+                    deps.vsDiffEnabled = false;
+                }
+            }
+            vsDiffRequestId = openVSCodeDiffForTool({
+                toolName: request.toolName,
+                input: request.input,
+                sessionId: deps.sessionPrefix,
+            });
+        }
+        if (!deps.showPermissionOverlayV2) {
+            throw new Error('permission overlay not initialized');
+        }
+        // Race: terminal overlay vs VS Code extension response
+        const overlayPromise = deps.showPermissionOverlayV2({
+            toolName: request.toolName,
+            args: request.input,
+            description: request.description,
+            diffLines,
+        });
+        let result;
+        if (vsDiffRequestId) {
+            // Race between terminal overlay and VS Code extension
+            const { promise: vsDiffPromise, abort: abortVsDiffWatch } = waitForDiffResponse(vsDiffRequestId, 120_000);
+            const raceResult = await Promise.race([
+                overlayPromise.then(r => ({ source: 'terminal', result: r })),
+                vsDiffPromise.then(r => ({ source: 'vscode', result: r })),
+            ]);
+            if (raceResult.source === 'terminal') {
+                result = raceResult.result;
+                // Terminal responded first — abort CLI poll BEFORE writing cancel response,
+                // so the poll doesn't eat the cancel file before the extension reads it
+                abortVsDiffWatch();
+                cancelDiffRequest(vsDiffRequestId);
+            }
+            else {
+                // VS Code responded first — resolve the overlay
+                const vsResponse = raceResult.result;
+                if (vsResponse && !vsResponse.cancelled) {
+                    result = vsResponse.accepted ? 'allow' : 'deny';
+                }
+                else {
+                    // VS Code response was null (timeout) or cancelled — wait for terminal
+                    result = await overlayPromise;
+                }
+                // Cancel the VS Code diff (clean up)
+                abortVsDiffWatch();
+                cancelDiffRequest(vsDiffRequestId);
+            }
+        }
+        else {
+            result = await overlayPromise;
+        }
+        // Handle result
+        if (result === 'allow-always') {
+            deps.grantSession?.(request.toolName);
+            deps.setMode?.('auto-accept');
+        }
+        // null result means cancelled, treat as deny
+        return result !== null && result !== 'deny';
+    };
+}

package/dist/index.d.ts

@@ -1,2 +1,12 @@
 #!/usr/bin/env node
-export {};
+import type { MCPManager } from '@compilr-dev/sdk';
+import { VERSION } from './utils/version.js';
+export { VERSION };
+/** Get the MCPManager instance (for /mcp command) */
+export declare function getMCPManager(): MCPManager | null;
+/**
+ * Get or lazily create an MCPManager instance.
+ * When no servers were configured at startup, mcpManagerInstance is null.
+ * This creates one on demand so the /mcp overlay can add servers at runtime.
+ */
+export declare function ensureMCPManager(): Promise<MCPManager>;