@ebowwa/coder 0.7.63 → 0.7.64

package/dist/core/permissions.js

@@ -0,0 +1,327 @@
+/**
+ * Permission System - Interactive permission prompts
+ */
+import * as readline from "readline";
+// ============================================
+// RISK LEVEL ASSESSMENT
+// ============================================
+const TOOL_RISK_LEVELS = {
+    // Low risk - read-only, non-destructive
+    Read: "low",
+    Glob: "low",
+    Grep: "low",
+    Task: "low",
+    // Medium risk - modifies files but reversible
+    Write: "medium",
+    Edit: "medium",
+    NotebookEdit: "medium",
+    // Bash is assessed dynamically based on command
+    // Default to medium, elevated to high/critical by assessRiskLevel
+    Bash: "medium",
+    // Critical risk - irreversible operations
+    // (handled by input analysis)
+};
+// Read-only commands that are safe to auto-approve
+const READ_ONLY_COMMANDS = [
+    /^date\b/,
+    /^ls\b/,
+    /^cat\b/,
+    /^head\b/,
+    /^tail\b/,
+    /^echo\b/,
+    /^pwd\b/,
+    /^whoami\b/,
+    /^which\b/,
+    /^uname\b/,
+    /^hostname\b/,
+    /^id\b/,
+    /^printenv\b/,
+    /^env\b/,
+    /^git\s+status\b/,
+    /^git\s+log\b/,
+    /^git\s+diff\b/,
+    /^git\s+branch\b/,
+    /^git\s+remote\b/,
+    /^git\s+rev-parse\b/,
+    /^git\s+show\b/,
+    /^npm\s+list\b/,
+    /^bun\s+--version\b/,
+    /^bun\s+-v\b/,
+    /^node\s+--version\b/,
+    /^node\s+-v\b/,
+    /^python\s+--version\b/,
+    /^python3\s+--version\b/,
+    /^uv\s+--version\b/,
+    /^doppler\s+\w+\s+--help\b/,
+];
+const CRITICAL_PATTERNS = [
+    /\brm\s+-rf\b/,
+    /\brm\s+-r\b/,
+    /\brm\s+[^-]/,
+    /\bgit\s+push\s+--force\b/,
+    /\bgit\s+reset\s+--hard\b/,
+    /\bgit\s+clean\s+-fd\b/,
+    /\bdrop\b/i,
+    /\bdelete\b/i,
+    /\btruncate\b/i,
+    /\bformat\b/i,
+    /\bdd\s+if=/,
+    /\bshred\b/,
+    /\b:\(\)\{\s*:\|:\s*&\s*\};\s*:\b/, // Fork bomb
+];
+/**
+ * Assess risk level for a tool operation
+ */
+export function assessRiskLevel(toolName, toolInput) {
+    // Start with base risk level
+    let riskLevel = TOOL_RISK_LEVELS[toolName] ?? "medium";
+    // Check for critical patterns in Bash commands
+    if (toolName === "Bash") {
+        const command = String(toolInput.command ?? "");
+        for (const pattern of CRITICAL_PATTERNS) {
+            if (pattern.test(command)) {
+                return "critical";
+            }
+        }
+        // Elevated commands increase risk
+        if (/\bsudo\b/.test(command) || /\bchmod\b/.test(command)) {
+            riskLevel = "high";
+        }
+    }
+    // Write to sensitive files increases risk
+    if (toolName === "Write" || toolName === "Edit") {
+        const filePath = String(toolInput.file_path ?? toolInput.path ?? "");
+        if (/\.(env|pem|key|secret|credentials)/.test(filePath)) {
+            riskLevel = "high";
+        }
+        if (/\/\.ssh\//.test(filePath) || /\/\.gnupg\//.test(filePath)) {
+            riskLevel = "critical";
+        }
+    }
+    return riskLevel;
+}
+/**
+ * Generate a human-readable description of the tool operation
+ */
+export function generateDescription(toolName, toolInput) {
+    switch (toolName) {
+        case "Read":
+            return `Read file: ${toolInput.file_path ?? "unknown"}`;
+        case "Write":
+            return `Write file: ${toolInput.file_path ?? "unknown"} (${String(toolInput.content ?? "").length} chars)`;
+        case "Edit":
+            return `Edit file: ${toolInput.file_path ?? "unknown"}`;
+        case "Bash":
+            return `Execute: ${String(toolInput.command ?? "").slice(0, 100)}${String(toolInput.command ?? "").length > 100 ? "..." : ""}`;
+        case "Glob":
+            return `Find files: ${toolInput.pattern ?? "*"}`;
+        case "Grep":
+            return `Search: "${toolInput.pattern ?? ""}" in ${toolInput.path ?? "."}`;
+        case "Task":
+            return `Spawn agent: ${toolInput.subagent_type ?? "unknown"}`;
+        default:
+            return `Use tool: ${toolName}`;
+    }
+}
+// ============================================
+// PERMISSION MANAGER
+// ============================================
+export class PermissionManager {
+    cache = {};
+    cacheTimeout = 5 * 60 * 1000; // 5 minutes
+    promptCallback;
+    mode;
+    constructor(mode = "default", promptCallback) {
+        this.mode = mode;
+        this.promptCallback = promptCallback ?? this.defaultPrompt.bind(this);
+    }
+    /**
+     * Check if a tool operation is permitted
+     */
+    async checkPermission(toolName, toolInput) {
+        // Bypass mode - always allow
+        if (this.mode === "bypassPermissions") {
+            return { decision: "allow" };
+        }
+        // DontAsk mode - always deny
+        if (this.mode === "dontAsk") {
+            return { decision: "deny", reason: "Permission mode is dontAsk" };
+        }
+        // AcceptEdits mode - allow file operations and non-critical Bash commands
+        if (this.mode === "acceptEdits") {
+            const fileTools = ["Read", "Write", "Edit", "Glob", "Grep"];
+            if (fileTools.includes(toolName)) {
+                return { decision: "allow" };
+            }
+            // Also allow non-critical Bash commands (low/medium risk)
+            if (toolName === "Bash") {
+                const riskLevel = assessRiskLevel(toolName, toolInput);
+                if (riskLevel === "low" || riskLevel === "medium") {
+                    return { decision: "allow" };
+                }
+            }
+        }
+        // Plan mode - deny all write operations
+        if (this.mode === "plan") {
+            const readOnlyTools = ["Read", "Glob", "Grep", "Task"];
+            if (readOnlyTools.includes(toolName)) {
+                return { decision: "allow" };
+            }
+            return { decision: "deny", reason: "Plan mode - write operations disabled" };
+        }
+        // Check cache for "always" decisions
+        const cacheKey = this.getCacheKey(toolName, toolInput);
+        const cached = this.cache[cacheKey];
+        if (cached && Date.now() - cached.timestamp < this.cacheTimeout) {
+            if (cached.decision === "allowAlways") {
+                return { decision: "allow", reason: "Previously approved (always)" };
+            }
+            if (cached.decision === "denyAlways") {
+                return { decision: "deny", reason: "Previously denied (always)" };
+            }
+        }
+        // Assess risk level
+        const riskLevel = assessRiskLevel(toolName, toolInput);
+        const description = generateDescription(toolName, toolInput);
+        // Create permission request
+        const request = {
+            toolName,
+            toolInput,
+            riskLevel,
+            description,
+            file: (toolInput.file_path ?? toolInput.path),
+            command: toolName === "Bash" ? toolInput.command : undefined,
+        };
+        // Prompt user for interactive/default modes
+        if (this.mode === "interactive" || this.mode === "default") {
+            const result = await this.promptCallback(request);
+            // Cache "always" decisions
+            if (result.decision === "allowAlways" || result.decision === "denyAlways") {
+                this.cache[cacheKey] = {
+                    decision: result.decision,
+                    timestamp: Date.now(),
+                };
+            }
+            return result;
+        }
+        // Default to allow for unknown modes
+        return { decision: "allow" };
+    }
+    /**
+     * Generate cache key for permission
+     */
+    getCacheKey(toolName, toolInput) {
+        // For file operations, key on file path
+        if (["Read", "Write", "Edit"].includes(toolName)) {
+            return `${toolName}:${toolInput.file_path ?? toolInput.path ?? "unknown"}`;
+        }
+        // For bash, key on command (first 100 chars)
+        if (toolName === "Bash") {
+            const cmd = String(toolInput.command ?? "").slice(0, 100);
+            return `${toolName}:${cmd}`;
+        }
+        // Default: key on tool name only
+        return toolName;
+    }
+    /**
+     * Default prompt implementation using readline
+     */
+    async defaultPrompt(request) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            // Format risk level with color
+            const riskColors = {
+                low: "\x1b[32m", // Green
+                medium: "\x1b[33m", // Yellow
+                high: "\x1b[31m", // Red
+                critical: "\x1b[35m", // Magenta
+            };
+            const riskColor = riskColors[request.riskLevel] ?? "\x1b[0m";
+            const reset = "\x1b[0m";
+            console.log("");
+            console.log(`\x1b[36m━━━ Permission Required ━━━\x1b[0m`);
+            console.log(`Tool: \x1b[1m${request.toolName}\x1b[0m`);
+            console.log(`Risk: ${riskColor}${request.riskLevel.toUpperCase()}${reset}`);
+            console.log(`Action: ${request.description}`);
+            if (request.file) {
+                console.log(`File: ${request.file}`);
+            }
+            if (request.command) {
+                console.log(`Command: ${request.command.slice(0, 200)}${request.command.length > 200 ? "..." : ""}`);
+            }
+            console.log("");
+            const options = "[y]es / [n]o / [a]lways / [d]eny always";
+            rl.question(`Allow? ${options}: `, (answer) => {
+                rl.close();
+                const input = answer.trim().toLowerCase();
+                switch (input) {
+                    case "y":
+                    case "yes":
+                        resolve({ decision: "allow" });
+                        break;
+                    case "a":
+                    case "always":
+                        resolve({ decision: "allowAlways" });
+                        break;
+                    case "d":
+                    case "deny":
+                    case "deny always":
+                        resolve({ decision: "denyAlways" });
+                        break;
+                    case "n":
+                    case "no":
+                    default:
+                        resolve({ decision: "deny" });
+                        break;
+                }
+            });
+        });
+    }
+    /**
+     * Clear permission cache
+     */
+    clearCache() {
+        this.cache = {};
+    }
+    /**
+     * Set permission mode
+     */
+    setMode(mode) {
+        this.mode = mode;
+        // Clear cache when mode changes
+        this.clearCache();
+    }
+}
+// ============================================
+// PERMISSION CATEGORIES
+// ============================================
+/**
+ * Tool categories for permission decisions
+ */
+export const TOOL_CATEGORIES = {
+    readOnly: ["Read", "Glob", "Grep", "Task"],
+    fileEdit: ["Write", "Edit", "NotebookEdit"],
+    system: ["Bash"],
+    network: [], // Future: HTTP requests, etc.
+};
+/**
+ * Check if tool is read-only
+ */
+export function isReadOnlyTool(toolName) {
+    return TOOL_CATEGORIES.readOnly.includes(toolName);
+}
+/**
+ * Check if tool modifies files
+ */
+export function isFileEditTool(toolName) {
+    return TOOL_CATEGORIES.fileEdit.includes(toolName);
+}
+/**
+ * Check if tool executes system commands
+ */
+export function isSystemTool(toolName) {
+    return TOOL_CATEGORIES.system.includes(toolName);
+}

package/dist/core/retry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Retry Logic - Exponential backoff with jitter for API failures
+ * Handles rate limits, network errors, and transient failures
+ */
+export interface RetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    jitterFactor?: number;
+    retryableStatusCodes?: number[];
+    onRetry?: (attempt: number, error: Error, delayMs: number) => void;
+}
+/**
+ * Execute a function with retry logic
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * Create a retry wrapper for fetch
+ */
+export declare function createFetchWithRetry(options?: RetryOptions): (url: string, init?: RequestInit) => Promise<Response>;
+/**
+ * Parse retry-after header from rate limit response
+ */
+export declare function parseRetryAfter(response: Response): number | null;
+//# sourceMappingURL=retry.d.ts.map

package/dist/core/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../packages/src/core/retry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACpE;AA4ED;;GAEG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE,YAAiB,GACzB,OAAO,CAAC,CAAC,CAAC,CAqCZ;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,GAAE,YAAiB,GACzB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAiBxD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI,CASjE"}

package/dist/core/retry.js

@@ -0,0 +1,121 @@
+/**
+ * Retry Logic - Exponential backoff with jitter for API failures
+ * Handles rate limits, network errors, and transient failures
+ */
+const DEFAULT_RETRY_OPTIONS = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    jitterFactor: 0.2,
+    retryableStatusCodes: [429, 500, 502, 503, 504, 529],
+    onRetry: undefined,
+};
+/**
+ * Calculate delay with exponential backoff and jitter
+ */
+function calculateDelay(attempt, baseDelayMs, maxDelayMs, jitterFactor) {
+    // Exponential backoff: baseDelay * 2^attempt
+    const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
+    // Add jitter to prevent thundering herd
+    const jitter = exponentialDelay * jitterFactor * (Math.random() * 2 - 1);
+    // Cap at max delay
+    return Math.min(exponentialDelay + jitter, maxDelayMs);
+}
+/**
+ * Check if an error is retryable
+ */
+function isRetryableError(error, retryableStatusCodes) {
+    // Check for rate limit errors
+    if (error.message.includes("429") || error.message.includes("rate limit")) {
+        return true;
+    }
+    // Check for server errors
+    if (error.message.includes("500") ||
+        error.message.includes("502") ||
+        error.message.includes("503") ||
+        error.message.includes("504")) {
+        return true;
+    }
+    // Check for network errors
+    if (error.message.includes("ECONNREFUSED") ||
+        error.message.includes("ENOTFOUND") ||
+        error.message.includes("ETIMEDOUT") ||
+        error.message.includes("network") ||
+        error.message.includes("fetch failed")) {
+        return true;
+    }
+    // Check for specific status codes in error message
+    for (const code of retryableStatusCodes) {
+        if (error.message.includes(String(code))) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Sleep for a given number of milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Execute a function with retry logic
+ */
+export async function withRetry(fn, options = {}) {
+    const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
+    let lastError = null;
+    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            // Check if we should retry
+            if (attempt < opts.maxRetries && isRetryableError(lastError, opts.retryableStatusCodes)) {
+                const delayMs = calculateDelay(attempt, opts.baseDelayMs, opts.maxDelayMs, opts.jitterFactor);
+                // Log retry attempt
+                if (opts.onRetry) {
+                    opts.onRetry(attempt + 1, lastError, delayMs);
+                }
+                else {
+                    console.warn(`\x1b[33mRetry ${attempt + 1}/${opts.maxRetries} after ${delayMs}ms: ${lastError.message}\x1b[0m`);
+                }
+                await sleep(delayMs);
+            }
+            else {
+                // Non-retryable error or max retries reached
+                throw lastError;
+            }
+        }
+    }
+    throw lastError || new Error("Max retries exceeded");
+}
+/**
+ * Create a retry wrapper for fetch
+ */
+export function createFetchWithRetry(options = {}) {
+    return async (url, init) => {
+        return withRetry(async () => {
+            const response = await fetch(url, init);
+            // Check for retryable status codes
+            if (options.retryableStatusCodes?.includes(response.status)) {
+                const text = await response.text();
+                throw new Error(`API error: ${response.status} - ${text}`);
+            }
+            return response;
+        }, options);
+    };
+}
+/**
+ * Parse retry-after header from rate limit response
+ */
+export function parseRetryAfter(response) {
+    const retryAfter = response.headers.get("retry-after");
+    if (retryAfter) {
+        const seconds = parseInt(retryAfter, 10);
+        if (!isNaN(seconds)) {
+            return seconds * 1000; // Convert to milliseconds
+        }
+    }
+    return null;
+}

package/dist/core/session-store.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Session Store - Backward compatibility layer
+ * Re-exports from composable sessions module
+ *
+ * @deprecated Import from "./sessions/index.js" instead for composable access
+ */
+export { SessionStore, SessionPersistence, SessionMetadataManager, SessionExporter, formatSessionSummary, printSessionsList, type SessionMetadata, type SessionMessage, type SessionToolUse, type SessionMetrics, type SessionContext, type SessionCheckpoint, type SessionEntry, type LoadedSession, type SessionSummary, type SessionFilter, type SessionEvent, type SessionEventType, type SessionEventHandler, type ExportFormat, type ISessionPersistence, type ISessionExporter, } from "./sessions/index.js";
+export { SessionStore as default } from "./sessions/index.js";
+//# sourceMappingURL=session-store.d.ts.map

package/dist/core/session-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-store.d.ts","sourceRoot":"","sources":["../../packages/src/core/session-store.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,sBAAsB,EACtB,eAAe,EACf,oBAAoB,EACpB,iBAAiB,EAEjB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACxB,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,GACtB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,YAAY,IAAI,OAAO,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/core/session-store.js

@@ -0,0 +1,10 @@
+/**
+ * Session Store - Backward compatibility layer
+ * Re-exports from composable sessions module
+ *
+ * @deprecated Import from "./sessions/index.js" instead for composable access
+ */
+// Re-export everything from the new composable module
+export { SessionStore, SessionPersistence, SessionMetadataManager, SessionExporter, formatSessionSummary, printSessionsList, } from "./sessions/index.js";
+// Default export
+export { SessionStore as default } from "./sessions/index.js";

package/dist/core/sessions/export.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Session Export - Export sessions to various formats
+ * Supports JSONL, JSON, and Markdown
+ */
+import type { LoadedSession, SessionSummary, ExportFormat, ISessionExporter } from "./types.js";
+import { SessionPersistence } from "./persistence.js";
+export declare class SessionExporter implements ISessionExporter {
+    private persistence;
+    constructor(persistence: SessionPersistence);
+    /**
+     * Export a loaded session to the specified format
+     */
+    export(session: LoadedSession, format: ExportFormat): string;
+    /**
+     * Export a session to a file
+     */
+    exportToFile(sessionId: string, format: ExportFormat, outputPath?: string): Promise<string>;
+    /**
+     * Export to JSONL format (raw session file)
+     */
+    private toJsonl;
+    /**
+     * Export to JSON format (pretty-printed)
+     */
+    private toJson;
+    /**
+     * Export to Markdown format
+     */
+    private toMarkdown;
+    /**
+     * Format a content block for markdown
+     */
+    private formatBlock;
+    /**
+     * Format a session summary for display
+     */
+    static formatSummary(session: SessionSummary): string;
+    /**
+     * Format relative time
+     */
+    static formatRelativeTime(date: Date): string;
+    /**
+     * Print sessions list for CLI
+     */
+    static printList(sessions: SessionSummary[]): void;
+}
+//# sourceMappingURL=export.d.ts.map

package/dist/core/sessions/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../packages/src/core/sessions/export.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EACV,aAAa,EACb,cAAc,EACd,YAAY,EACZ,gBAAgB,EAEjB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAEtD,qBAAa,eAAgB,YAAW,gBAAgB;IACtD,OAAO,CAAC,WAAW,CAAqB;gBAE5B,WAAW,EAAE,kBAAkB;IAI3C;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,aAAa,EAAE,MAAM,EAAE,YAAY,GAAG,MAAM;IAa5D;;OAEG;IACG,YAAY,CAChB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,YAAY,EACpB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,MAAM,CAAC;IAgBlB;;OAEG;IACH,OAAO,CAAC,OAAO;IAkCf;;OAEG;IACH,OAAO,CAAC,MAAM;IAId;;OAEG;IACH,OAAO,CAAC,UAAU;IA8FlB;;OAEG;IACH,OAAO,CAAC,WAAW;IA8CnB;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM;IAmCrD;;OAEG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;IAe7C;;OAEG;IACH,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,cAAc,EAAE,GAAG,IAAI;CAiBnD"}