@ebowwa/coder 0.2.1 → 0.7.64

package/packages/src/core/permissions.ts

@@ -0,0 +1,431 @@
+/**
+ * Permission System - Interactive permission prompts
+ */
+
+import * as readline from "readline";
+
+// ============================================
+// TYPES
+// ============================================
+
+export type PermissionMode =
+  | "default"
+  | "acceptEdits"
+  | "bypassPermissions"
+  | "dontAsk"
+  | "interactive"
+  | "plan";
+
+export type PermissionDecision =
+  | "allow"
+  | "deny"
+  | "allowAlways"
+  | "denyAlways";
+
+export interface PermissionRequest {
+  toolName: string;
+  toolInput: Record<string, unknown>;
+  riskLevel: "low" | "medium" | "high" | "critical";
+  description: string;
+  file?: string;
+  command?: string;
+}
+
+export interface PermissionResult {
+  decision: PermissionDecision;
+  reason?: string;
+}
+
+export interface PermissionCache {
+  [key: string]: {
+    decision: PermissionDecision;
+    timestamp: number;
+  };
+}
+
+export type PermissionPromptCallback = (
+  request: PermissionRequest
+) => Promise<PermissionResult>;
+
+// ============================================
+// RISK LEVEL ASSESSMENT
+// ============================================
+
+const TOOL_RISK_LEVELS: Record<string, "low" | "medium" | "high" | "critical"> = {
+  // 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: string,
+  toolInput: Record<string, unknown>
+): "low" | "medium" | "high" | "critical" {
+  // 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: string,
+  toolInput: Record<string, unknown>
+): string {
+  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 {
+  private cache: PermissionCache = {};
+  private cacheTimeout = 5 * 60 * 1000; // 5 minutes
+  private promptCallback: PermissionPromptCallback;
+  private mode: PermissionMode;
+
+  constructor(
+    mode: PermissionMode = "default",
+    promptCallback?: PermissionPromptCallback
+  ) {
+    this.mode = mode;
+    this.promptCallback = promptCallback ?? this.defaultPrompt.bind(this);
+  }
+
+  /**
+   * Check if a tool operation is permitted
+   */
+  async checkPermission(
+    toolName: string,
+    toolInput: Record<string, unknown>
+  ): Promise<PermissionResult> {
+    // 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: PermissionRequest = {
+      toolName,
+      toolInput,
+      riskLevel,
+      description,
+      file: (toolInput.file_path ?? toolInput.path) as string | undefined,
+      command: toolName === "Bash" ? toolInput.command as string : 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
+   */
+  private getCacheKey(toolName: string, toolInput: Record<string, unknown>): string {
+    // 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
+   */
+  private async defaultPrompt(request: PermissionRequest): Promise<PermissionResult> {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      // Format risk level with color
+      const riskColors: Record<string, string> = {
+        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(): void {
+    this.cache = {};
+  }
+
+  /**
+   * Set permission mode
+   */
+  setMode(mode: PermissionMode): void {
+    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.
+} as const;
+
+/**
+ * Check if tool is read-only
+ */
+export function isReadOnlyTool(toolName: string): boolean {
+  return TOOL_CATEGORIES.readOnly.includes(toolName as typeof TOOL_CATEGORIES.readOnly[number]);
+}
+
+/**
+ * Check if tool modifies files
+ */
+export function isFileEditTool(toolName: string): boolean {
+  return TOOL_CATEGORIES.fileEdit.includes(toolName as typeof TOOL_CATEGORIES.fileEdit[number]);
+}
+
+/**
+ * Check if tool executes system commands
+ */
+export function isSystemTool(toolName: string): boolean {
+  return TOOL_CATEGORIES.system.includes(toolName as typeof TOOL_CATEGORIES.system[number]);
+}

package/packages/src/core/retry.ts

@@ -0,0 +1,170 @@
+/**
+ * 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;
+}
+
+const DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 3,
+  baseDelayMs: 1000,
+  maxDelayMs: 30000,
+  jitterFactor: 0.2,
+  retryableStatusCodes: [429, 500, 502, 503, 504, 529],
+  onRetry: undefined as ((attempt: number, error: Error, delayMs: number) => void) | undefined,
+};
+
+/**
+ * Calculate delay with exponential backoff and jitter
+ */
+function calculateDelay(
+  attempt: number,
+  baseDelayMs: number,
+  maxDelayMs: number,
+  jitterFactor: number
+): number {
+  // 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: Error,
+  retryableStatusCodes: number[]
+): boolean {
+  // 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: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Execute a function with retry logic
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {}
+): Promise<T> {
+  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
+  let lastError: Error | null = 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: RetryOptions = {}
+): (url: string, init?: RequestInit) => Promise<Response> {
+  return async (url: string, init?: RequestInit): Promise<Response> => {
+    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: Response): number | null {
+  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/packages/src/core/session-store.ts

@@ -0,0 +1,36 @@
+/**
+ * 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,
+  // Types
+  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";
+
+// Default export
+export { SessionStore as default } from "./sessions/index.js";