sparkecoder 0.1.3 → 0.1.5

package/dist/agent/index.js

@@ -2,12 +2,12 @@
 import {
   streamText,
   generateText as generateText2,
-  tool as tool7,
+  tool as tool6,
   stepCountIs
 } from "ai";
 import { gateway as gateway2 } from "@ai-sdk/gateway";
-import { z as z8 } from "zod";
-import { nanoid as nanoid2 } from "nanoid";
+import { z as z7 } from "zod";
+import { nanoid as nanoid3 } from "nanoid";
 
 // src/db/index.ts
 import Database from "better-sqlite3";
@@ -84,6 +84,37 @@ var terminals = sqliteTable("terminals", {
   createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
   stoppedAt: integer("stopped_at", { mode: "timestamp" })
 });
+var activeStreams = sqliteTable("active_streams", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  streamId: text("stream_id").notNull().unique(),
+  // Unique stream identifier
+  status: text("status", { enum: ["active", "finished", "error"] }).notNull().default("active"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  finishedAt: integer("finished_at", { mode: "timestamp" })
+});
+var checkpoints = sqliteTable("checkpoints", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  // The message sequence number this checkpoint was created BEFORE
+  // (i.e., the state before this user message was processed)
+  messageSequence: integer("message_sequence").notNull(),
+  // Optional git commit hash if in a git repo
+  gitHead: text("git_head"),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var fileBackups = sqliteTable("file_backups", {
+  id: text("id").primaryKey(),
+  checkpointId: text("checkpoint_id").notNull().references(() => checkpoints.id, { onDelete: "cascade" }),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  // Relative path from working directory
+  filePath: text("file_path").notNull(),
+  // Original content (null means file didn't exist before)
+  originalContent: text("original_content"),
+  // Whether the file existed before this checkpoint
+  existed: integer("existed", { mode: "boolean" }).notNull().default(true),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
 
 // src/db/index.ts
 var db = null;
@@ -114,6 +145,12 @@ var sessionQueries = {
   updateStatus(id, status) {
     return getDb().update(sessions).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
   },
+  updateModel(id, model) {
+    return getDb().update(sessions).set({ model, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
+  },
+  update(id, updates) {
+    return getDb().update(sessions).set({ ...updates, updatedAt: /* @__PURE__ */ new Date() }).where(eq(sessions.id, id)).returning().get();
+  },
   delete(id) {
     const result = getDb().delete(sessions).where(eq(sessions.id, id)).run();
     return result.changes > 0;
@@ -187,6 +224,19 @@ var messageQueries = {
   deleteBySession(sessionId) {
     const result = getDb().delete(messages).where(eq(messages.sessionId, sessionId)).run();
     return result.changes;
+  },
+  /**
+   * Delete all messages with sequence >= the given sequence number
+   * (Used when reverting to a checkpoint)
+   */
+  deleteFromSequence(sessionId, fromSequence) {
+    const result = getDb().delete(messages).where(
+      and(
+        eq(messages.sessionId, sessionId),
+        sql`sequence >= ${fromSequence}`
+      )
+    ).run();
+    return result.changes;
   }
 };
 var toolExecutionQueries = {
@@ -230,6 +280,19 @@ var toolExecutionQueries = {
   },
   getBySession(sessionId) {
     return getDb().select().from(toolExecutions).where(eq(toolExecutions.sessionId, sessionId)).orderBy(toolExecutions.startedAt).all();
+  },
+  /**
+   * Delete all tool executions after a given timestamp
+   * (Used when reverting to a checkpoint)
+   */
+  deleteAfterTime(sessionId, afterTime) {
+    const result = getDb().delete(toolExecutions).where(
+      and(
+        eq(toolExecutions.sessionId, sessionId),
+        sql`started_at > ${afterTime.getTime()}`
+      )
+    ).run();
+    return result.changes;
   }
 };
 var todoQueries = {
@@ -295,54 +358,73 @@ var skillQueries = {
     return !!result;
   }
 };
-var terminalQueries = {
+var fileBackupQueries = {
   create(data) {
     const id = nanoid();
-    const result = getDb().insert(terminals).values({
+    const result = getDb().insert(fileBackups).values({
       id,
-      ...data,
+      checkpointId: data.checkpointId,
+      sessionId: data.sessionId,
+      filePath: data.filePath,
+      originalContent: data.originalContent,
+      existed: data.existed,
       createdAt: /* @__PURE__ */ new Date()
     }).returning().get();
     return result;
   },
-  getById(id) {
-    return getDb().select().from(terminals).where(eq(terminals.id, id)).get();
+  getByCheckpoint(checkpointId) {
+    return getDb().select().from(fileBackups).where(eq(fileBackups.checkpointId, checkpointId)).all();
   },
   getBySession(sessionId) {
-    return getDb().select().from(terminals).where(eq(terminals.sessionId, sessionId)).orderBy(desc(terminals.createdAt)).all();
+    return getDb().select().from(fileBackups).where(eq(fileBackups.sessionId, sessionId)).orderBy(fileBackups.createdAt).all();
   },
-  getRunning(sessionId) {
-    return getDb().select().from(terminals).where(
+  /**
+   * Get all file backups from a given checkpoint sequence onwards (inclusive)
+   * (Used when reverting - need to restore these files)
+   * 
+   * When reverting to checkpoint X, we need backups from checkpoint X and all later ones
+   * because checkpoint X's backups represent the state BEFORE processing message X.
+   */
+  getFromSequence(sessionId, messageSequence) {
+    const checkpointsFrom = getDb().select().from(checkpoints).where(
       and(
-        eq(terminals.sessionId, sessionId),
-        eq(terminals.status, "running")
+        eq(checkpoints.sessionId, sessionId),
+        sql`message_sequence >= ${messageSequence}`
       )
     ).all();
+    if (checkpointsFrom.length === 0) {
+      return [];
+    }
+    const checkpointIds = checkpointsFrom.map((c) => c.id);
+    const allBackups = [];
+    for (const cpId of checkpointIds) {
+      const backups = getDb().select().from(fileBackups).where(eq(fileBackups.checkpointId, cpId)).all();
+      allBackups.push(...backups);
+    }
+    return allBackups;
   },
-  updateStatus(id, status, exitCode, error) {
-    return getDb().update(terminals).set({
-      status,
-      exitCode,
-      error,
-      stoppedAt: status !== "running" ? /* @__PURE__ */ new Date() : void 0
-    }).where(eq(terminals.id, id)).returning().get();
-  },
-  updatePid(id, pid) {
-    return getDb().update(terminals).set({ pid }).where(eq(terminals.id, id)).returning().get();
-  },
-  delete(id) {
-    const result = getDb().delete(terminals).where(eq(terminals.id, id)).run();
-    return result.changes > 0;
+  /**
+   * Check if a file already has a backup in the current checkpoint
+   */
+  hasBackup(checkpointId, filePath) {
+    const result = getDb().select().from(fileBackups).where(
+      and(
+        eq(fileBackups.checkpointId, checkpointId),
+        eq(fileBackups.filePath, filePath)
+      )
+    ).get();
+    return !!result;
   },
   deleteBySession(sessionId) {
-    const result = getDb().delete(terminals).where(eq(terminals.sessionId, sessionId)).run();
+    const result = getDb().delete(fileBackups).where(eq(fileBackups.sessionId, sessionId)).run();
     return result.changes;
   }
 };
 
 // src/config/index.ts
-import { existsSync, readFileSync } from "fs";
-import { resolve, dirname } from "path";
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from "fs";
+import { resolve, dirname, join } from "path";
+import { homedir, platform } from "os";
 
 // src/config/types.ts
 import { z } from "zod";
@@ -419,12 +501,20 @@ function requiresApproval(toolName, sessionConfig) {
   }
   return false;
 }
+var PROVIDER_ENV_MAP = {
+  anthropic: "ANTHROPIC_API_KEY",
+  openai: "OPENAI_API_KEY",
+  google: "GOOGLE_GENERATIVE_AI_API_KEY",
+  xai: "XAI_API_KEY",
+  "ai-gateway": "AI_GATEWAY_API_KEY"
+};
+var SUPPORTED_PROVIDERS = Object.keys(PROVIDER_ENV_MAP);
 
 // src/tools/bash.ts
 import { tool } from "ai";
 import { z as z2 } from "zod";
-import { exec } from "child_process";
-import { promisify } from "util";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
 
 // src/utils/truncate.ts
 var MAX_OUTPUT_CHARS = 1e4;
@@ -447,9 +537,253 @@ function calculateContextSize(messages2) {
   }, 0);
 }
 
-// src/tools/bash.ts
+// src/terminal/tmux.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { mkdir, writeFile, readFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { nanoid as nanoid2 } from "nanoid";
 var execAsync = promisify(exec);
-var COMMAND_TIMEOUT = 6e4;
+var SESSION_PREFIX = "spark_";
+var LOG_BASE_DIR = ".sparkecoder/sessions";
+var tmuxAvailableCache = null;
+async function isTmuxAvailable() {
+  if (tmuxAvailableCache !== null) {
+    return tmuxAvailableCache;
+  }
+  try {
+    const { stdout } = await execAsync("tmux -V");
+    tmuxAvailableCache = true;
+    return true;
+  } catch (error) {
+    tmuxAvailableCache = false;
+    console.log(`[tmux] Not available: ${error instanceof Error ? error.message : "unknown error"}`);
+    return false;
+  }
+}
+function generateTerminalId() {
+  return "t" + nanoid2(9);
+}
+function getSessionName(terminalId) {
+  return `${SESSION_PREFIX}${terminalId}`;
+}
+function getLogDir(terminalId, workingDirectory, sessionId) {
+  if (sessionId) {
+    return join2(workingDirectory, LOG_BASE_DIR, sessionId, "terminals", terminalId);
+  }
+  return join2(workingDirectory, ".sparkecoder/terminals", terminalId);
+}
+function shellEscape(str) {
+  return `'${str.replace(/'/g, "'\\''")}'`;
+}
+async function initLogDir(terminalId, meta, workingDirectory) {
+  const logDir = getLogDir(terminalId, workingDirectory, meta.sessionId);
+  await mkdir(logDir, { recursive: true });
+  await writeFile(join2(logDir, "meta.json"), JSON.stringify(meta, null, 2));
+  await writeFile(join2(logDir, "output.log"), "");
+  return logDir;
+}
+async function pollUntil(condition, options) {
+  const { timeout, interval = 100 } = options;
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    if (await condition()) {
+      return true;
+    }
+    await new Promise((r) => setTimeout(r, interval));
+  }
+  return false;
+}
+async function runSync(command, workingDirectory, options) {
+  if (!options) {
+    throw new Error("runSync: options parameter is required (must include sessionId)");
+  }
+  const id = options.terminalId || generateTerminalId();
+  const session = getSessionName(id);
+  const logDir = await initLogDir(id, {
+    id,
+    command,
+    cwd: workingDirectory,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: options.sessionId,
+    background: false
+  }, workingDirectory);
+  const logFile = join2(logDir, "output.log");
+  const exitCodeFile = join2(logDir, "exit_code");
+  const timeout = options.timeout || 12e4;
+  try {
+    const wrappedCommand = `(${command}) 2>&1 | tee -a ${shellEscape(logFile)}; echo $? > ${shellEscape(exitCodeFile)}`;
+    await execAsync(
+      `tmux new-session -d -s ${session} -c ${shellEscape(workingDirectory)} ${shellEscape(wrappedCommand)}`,
+      { timeout: 5e3 }
+    );
+    try {
+      await execAsync(
+        `tmux pipe-pane -t ${session} -o 'cat >> ${shellEscape(logFile)}'`,
+        { timeout: 1e3 }
+      );
+    } catch {
+    }
+    const completed = await pollUntil(
+      async () => {
+        try {
+          await execAsync(`tmux has-session -t ${session}`, { timeout: 1e3 });
+          return false;
+        } catch {
+          return true;
+        }
+      },
+      { timeout, interval: 100 }
+    );
+    if (!completed) {
+      try {
+        await execAsync(`tmux kill-session -t ${session}`, { timeout: 5e3 });
+      } catch {
+      }
+      let output2 = "";
+      try {
+        output2 = await readFile(logFile, "utf-8");
+      } catch {
+      }
+      return {
+        id,
+        output: output2.trim(),
+        exitCode: 124,
+        // Standard timeout exit code
+        status: "error"
+      };
+    }
+    await new Promise((r) => setTimeout(r, 50));
+    let output = "";
+    try {
+      output = await readFile(logFile, "utf-8");
+    } catch {
+    }
+    let exitCode = 0;
+    try {
+      if (existsSync2(exitCodeFile)) {
+        const exitCodeStr = await readFile(exitCodeFile, "utf-8");
+        exitCode = parseInt(exitCodeStr.trim(), 10) || 0;
+      }
+    } catch {
+    }
+    return {
+      id,
+      output: output.trim(),
+      exitCode,
+      status: "completed"
+    };
+  } catch (error) {
+    try {
+      await execAsync(`tmux kill-session -t ${session}`, { timeout: 5e3 });
+    } catch {
+    }
+    throw error;
+  }
+}
+async function runBackground(command, workingDirectory, options) {
+  if (!options) {
+    throw new Error("runBackground: options parameter is required (must include sessionId)");
+  }
+  const id = options.terminalId || generateTerminalId();
+  const session = getSessionName(id);
+  const logDir = await initLogDir(id, {
+    id,
+    command,
+    cwd: workingDirectory,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sessionId: options.sessionId,
+    background: true
+  }, workingDirectory);
+  const logFile = join2(logDir, "output.log");
+  const wrappedCommand = `(${command}) 2>&1 | tee -a ${shellEscape(logFile)}`;
+  await execAsync(
+    `tmux new-session -d -s ${session} -c ${shellEscape(workingDirectory)} ${shellEscape(wrappedCommand)}`,
+    { timeout: 5e3 }
+  );
+  return {
+    id,
+    output: "",
+    exitCode: 0,
+    status: "running"
+  };
+}
+async function getLogs(terminalId, workingDirectory, options = {}) {
+  const session = getSessionName(terminalId);
+  const logDir = getLogDir(terminalId, workingDirectory, options.sessionId);
+  const logFile = join2(logDir, "output.log");
+  let isRunning = false;
+  try {
+    await execAsync(`tmux has-session -t ${session}`, { timeout: 5e3 });
+    isRunning = true;
+  } catch {
+  }
+  if (isRunning) {
+    try {
+      const lines = options.tail || 1e3;
+      const { stdout } = await execAsync(
+        `tmux capture-pane -t ${session} -p -S -${lines}`,
+        { timeout: 5e3, maxBuffer: 10 * 1024 * 1024 }
+      );
+      return { output: stdout.trim(), status: "running" };
+    } catch {
+    }
+  }
+  try {
+    let output = await readFile(logFile, "utf-8");
+    if (options.tail) {
+      const lines = output.split("\n");
+      output = lines.slice(-options.tail).join("\n");
+    }
+    return { output: output.trim(), status: isRunning ? "running" : "stopped" };
+  } catch {
+    return { output: "", status: "unknown" };
+  }
+}
+async function killTerminal(terminalId) {
+  const session = getSessionName(terminalId);
+  try {
+    await execAsync(`tmux kill-session -t ${session}`, { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function sendInput(terminalId, input, options = {}) {
+  const session = getSessionName(terminalId);
+  const { pressEnter = true } = options;
+  try {
+    await execAsync(`tmux has-session -t ${session}`, { timeout: 1e3 });
+    await execAsync(
+      `tmux send-keys -t ${session} -l ${shellEscape(input)}`,
+      { timeout: 1e3 }
+    );
+    if (pressEnter) {
+      await execAsync(
+        `tmux send-keys -t ${session} Enter`,
+        { timeout: 1e3 }
+      );
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function sendKey(terminalId, key) {
+  const session = getSessionName(terminalId);
+  try {
+    await execAsync(`tmux has-session -t ${session}`, { timeout: 1e3 });
+    await execAsync(`tmux send-keys -t ${session} ${key}`, { timeout: 1e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/tools/bash.ts
+var execAsync2 = promisify2(exec2);
+var COMMAND_TIMEOUT = 12e4;
 var MAX_OUTPUT_CHARS2 = 1e4;
 var BLOCKED_COMMANDS = [
   "rm -rf /",
@@ -466,66 +800,226 @@ function isBlockedCommand(command) {
   );
 }
 var bashInputSchema = z2.object({
-  command: z2.string().describe("The bash command to execute. Can be a single command or a pipeline.")
+  command: z2.string().optional().describe("The command to execute. Required for running new commands."),
+  background: z2.boolean().default(false).describe("Run the command in background mode (for dev servers, watchers). Returns immediately with terminal ID."),
+  id: z2.string().optional().describe("Terminal ID. Use to get logs from, send input to, or kill an existing terminal."),
+  kill: z2.boolean().optional().describe("Kill the terminal with the given ID."),
+  tail: z2.number().optional().describe("Number of lines to return from the end of output (for logs)."),
+  input: z2.string().optional().describe("Send text input to an interactive terminal (requires id). Used for responding to prompts."),
+  key: z2.enum(["Enter", "Escape", "Up", "Down", "Left", "Right", "Tab", "C-c", "C-d", "y", "n"]).optional().describe('Send a special key to an interactive terminal (requires id). Use "y" or "n" for yes/no prompts.')
 });
+var useTmux = null;
+async function shouldUseTmux() {
+  if (useTmux === null) {
+    useTmux = await isTmuxAvailable();
+    if (!useTmux) {
+      console.warn("[bash] tmux not available, using fallback exec mode");
+    }
+  }
+  return useTmux;
+}
+async function execFallback(command, workingDirectory, onOutput) {
+  try {
+    const { stdout, stderr } = await execAsync2(command, {
+      cwd: workingDirectory,
+      timeout: COMMAND_TIMEOUT,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    const output = truncateOutput(stdout + (stderr ? `
+${stderr}` : ""), MAX_OUTPUT_CHARS2);
+    onOutput?.(output);
+    return {
+      success: true,
+      output,
+      exitCode: 0
+    };
+  } catch (error) {
+    const output = truncateOutput(
+      (error.stdout || "") + (error.stderr ? `
+${error.stderr}` : ""),
+      MAX_OUTPUT_CHARS2
+    );
+    onOutput?.(output || error.message);
+    if (error.killed) {
+      return {
+        success: false,
+        error: `Command timed out after ${COMMAND_TIMEOUT / 1e3} seconds`,
+        output,
+        exitCode: 124
+      };
+    }
+    return {
+      success: false,
+      error: error.message,
+      output,
+      exitCode: error.code ?? 1
+    };
+  }
+}
 function createBashTool(options) {
   return tool({
-    description: `Execute a bash command in the terminal. The command runs in the working directory: ${options.workingDirectory}. 
-Use this for running shell commands, scripts, git operations, package managers (npm, pip, etc.), and other CLI tools.
-Long outputs will be automatically truncated. Commands have a 60 second timeout.
-IMPORTANT: Avoid destructive commands. Be careful with rm, chmod, and similar operations.`,
+    description: `Execute commands in the terminal. Every command runs in its own session with logs saved to disk.
+
+**Run a command (default - waits for completion):**
+bash({ command: "npm install" })
+bash({ command: "git status" })
+
+**Run in background (for dev servers, watchers, or interactive commands):**
+bash({ command: "npm run dev", background: true })
+\u2192 Returns { id: "abc123" } - save this ID
+
+**Check on a background process:**
+bash({ id: "abc123" })
+bash({ id: "abc123", tail: 50 })  // last 50 lines only
+
+**Stop a background process:**
+bash({ id: "abc123", kill: true })
+
+**Respond to interactive prompts (for yes/no questions, etc.):**
+bash({ id: "abc123", key: "y" })   // send 'y' for yes
+bash({ id: "abc123", key: "n" })   // send 'n' for no
+bash({ id: "abc123", key: "Enter" })  // press Enter
+bash({ id: "abc123", input: "my text" })  // send text input
+
+**IMPORTANT for interactive commands:**
+- Use --yes, -y, or similar flags to avoid prompts when available
+- For create-next-app: add --yes to accept defaults
+- For npm: add --yes or -y to skip confirmation
+- If prompts are unavoidable, run in background mode and use input/key to respond
+
+Logs are saved to .sparkecoder/terminals/{id}/output.log`,
     inputSchema: bashInputSchema,
-    execute: async ({ command }) => {
+    execute: async (inputArgs) => {
+      const { command, background, id, kill, tail, input: textInput, key } = inputArgs;
+      if (id) {
+        if (kill) {
+          const success = await killTerminal(id);
+          return {
+            success,
+            id,
+            status: success ? "stopped" : "not_found",
+            message: success ? `Terminal ${id} stopped` : `Terminal ${id} not found or already stopped`
+          };
+        }
+        if (textInput !== void 0) {
+          const success = await sendInput(id, textInput, { pressEnter: true });
+          if (!success) {
+            return {
+              success: false,
+              id,
+              error: `Terminal ${id} not found or not running`
+            };
+          }
+          await new Promise((r) => setTimeout(r, 300));
+          const { output: output2, status: status2 } = await getLogs(id, options.workingDirectory, { tail: tail || 50, sessionId: options.sessionId });
+          const truncatedOutput2 = truncateOutput(output2, MAX_OUTPUT_CHARS2);
+          return {
+            success: true,
+            id,
+            output: truncatedOutput2,
+            status: status2,
+            message: `Sent input "${textInput}" to terminal`
+          };
+        }
+        if (key) {
+          const success = await sendKey(id, key);
+          if (!success) {
+            return {
+              success: false,
+              id,
+              error: `Terminal ${id} not found or not running`
+            };
+          }
+          await new Promise((r) => setTimeout(r, 300));
+          const { output: output2, status: status2 } = await getLogs(id, options.workingDirectory, { tail: tail || 50, sessionId: options.sessionId });
+          const truncatedOutput2 = truncateOutput(output2, MAX_OUTPUT_CHARS2);
+          return {
+            success: true,
+            id,
+            output: truncatedOutput2,
+            status: status2,
+            message: `Sent key "${key}" to terminal`
+          };
+        }
+        const { output, status } = await getLogs(id, options.workingDirectory, { tail, sessionId: options.sessionId });
+        const truncatedOutput = truncateOutput(output, MAX_OUTPUT_CHARS2);
+        return {
+          success: true,
+          id,
+          output: truncatedOutput,
+          status
+        };
+      }
+      if (!command) {
+        return {
+          success: false,
+          error: 'Either "command" (to run a new command) or "id" (to check/kill/send input) is required'
+        };
+      }
       if (isBlockedCommand(command)) {
         return {
           success: false,
           error: "This command is blocked for safety reasons.",
-          stdout: "",
-          stderr: "",
+          output: "",
           exitCode: 1
         };
       }
-      try {
-        const { stdout, stderr } = await execAsync(command, {
-          cwd: options.workingDirectory,
-          timeout: COMMAND_TIMEOUT,
-          maxBuffer: 10 * 1024 * 1024,
-          // 10MB buffer
-          shell: "/bin/bash"
-        });
-        const truncatedStdout = truncateOutput(stdout, MAX_OUTPUT_CHARS2);
-        const truncatedStderr = truncateOutput(stderr, MAX_OUTPUT_CHARS2 / 2);
-        if (options.onOutput) {
-          options.onOutput(truncatedStdout);
+      const canUseTmux = await shouldUseTmux();
+      if (background) {
+        if (!canUseTmux) {
+          return {
+            success: false,
+            error: "Background mode requires tmux to be installed. Install with: brew install tmux (macOS) or apt install tmux (Linux)"
+          };
         }
+        const terminalId = generateTerminalId();
+        options.onProgress?.({ terminalId, status: "started", command });
+        const result = await runBackground(command, options.workingDirectory, {
+          sessionId: options.sessionId,
+          terminalId
+        });
         return {
           success: true,
-          stdout: truncatedStdout,
-          stderr: truncatedStderr,
-          exitCode: 0
+          id: result.id,
+          status: "running",
+          message: `Started background process. Use bash({ id: "${result.id}" }) to check logs.`
         };
-      } catch (error) {
-        const stdout = error.stdout ? truncateOutput(error.stdout, MAX_OUTPUT_CHARS2) : "";
-        const stderr = error.stderr ? truncateOutput(error.stderr, MAX_OUTPUT_CHARS2) : "";
-        if (options.onOutput) {
-          options.onOutput(stderr || error.message);
-        }
-        if (error.killed) {
+      }
+      if (canUseTmux) {
+        const terminalId = generateTerminalId();
+        options.onProgress?.({ terminalId, status: "started", command });
+        try {
+          const result = await runSync(command, options.workingDirectory, {
+            sessionId: options.sessionId,
+            timeout: COMMAND_TIMEOUT,
+            terminalId
+          });
+          const truncatedOutput = truncateOutput(result.output, MAX_OUTPUT_CHARS2);
+          options.onOutput?.(truncatedOutput);
+          options.onProgress?.({ terminalId, status: "completed", command });
+          return {
+            success: result.exitCode === 0,
+            id: result.id,
+            output: truncatedOutput,
+            exitCode: result.exitCode,
+            status: result.status
+          };
+        } catch (error) {
+          options.onProgress?.({ terminalId, status: "completed", command });
           return {
             success: false,
-            error: `Command timed out after ${COMMAND_TIMEOUT / 1e3} seconds`,
-            stdout,
-            stderr,
-            exitCode: 124
-            // Standard timeout exit code
+            error: error.message,
+            output: "",
+            exitCode: 1
           };
         }
+      } else {
+        const result = await execFallback(command, options.workingDirectory, options.onOutput);
         return {
-          success: false,
-          error: error.message,
-          stdout,
-          stderr,
-          exitCode: error.code ?? 1
+          success: result.success,
+          output: result.output,
+          exitCode: result.exitCode,
+          error: result.error
         };
       }
     }
@@ -535,9 +1029,9 @@ IMPORTANT: Avoid destructive commands. Be careful with rm, chmod, and similar op
 // src/tools/read-file.ts
 import { tool as tool2 } from "ai";
 import { z as z3 } from "zod";
-import { readFile, stat } from "fs/promises";
+import { readFile as readFile2, stat } from "fs/promises";
 import { resolve as resolve2, relative, isAbsolute } from "path";
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var MAX_OUTPUT_CHARS3 = 5e4;
 var readFileInputSchema = z3.object({
@@ -562,7 +1056,7 @@ Use this to understand existing code, check file contents, or gather context.`,
             content: null
           };
         }
-        if (!existsSync2(absolutePath)) {
+        if (!existsSync3(absolutePath)) {
           return {
             success: false,
             error: `File not found: ${path}`,
@@ -584,7 +1078,7 @@ Use this to understand existing code, check file contents, or gather context.`,
             content: null
           };
         }
-        let content = await readFile(absolutePath, "utf-8");
+        let content = await readFile2(absolutePath, "utf-8");
         if (startLine !== void 0 || endLine !== void 0) {
           const lines = content.split("\n");
           const start = (startLine ?? 1) - 1;
@@ -632,9 +1126,62 @@ Use this to understand existing code, check file contents, or gather context.`,
 // src/tools/write-file.ts
 import { tool as tool3 } from "ai";
 import { z as z4 } from "zod";
-import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
-import { resolve as resolve3, relative as relative2, isAbsolute as isAbsolute2, dirname as dirname2 } from "path";
-import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
+import { resolve as resolve4, relative as relative3, isAbsolute as isAbsolute2, dirname as dirname3 } from "path";
+import { existsSync as existsSync5 } from "fs";
+
+// src/checkpoints/index.ts
+import { readFile as readFile3, writeFile as writeFile2, unlink, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve3, relative as relative2, dirname as dirname2 } from "path";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execAsync3 = promisify3(exec3);
+var activeManagers = /* @__PURE__ */ new Map();
+function getCheckpointManager(sessionId, workingDirectory) {
+  let manager = activeManagers.get(sessionId);
+  if (!manager) {
+    manager = {
+      sessionId,
+      workingDirectory,
+      currentCheckpointId: null
+    };
+    activeManagers.set(sessionId, manager);
+  }
+  return manager;
+}
+async function backupFile(sessionId, workingDirectory, filePath) {
+  const manager = getCheckpointManager(sessionId, workingDirectory);
+  if (!manager.currentCheckpointId) {
+    console.warn("[checkpoint] No active checkpoint, skipping file backup");
+    return null;
+  }
+  const absolutePath = resolve3(workingDirectory, filePath);
+  const relativePath = relative2(workingDirectory, absolutePath);
+  if (fileBackupQueries.hasBackup(manager.currentCheckpointId, relativePath)) {
+    return null;
+  }
+  let originalContent = null;
+  let existed = false;
+  if (existsSync4(absolutePath)) {
+    try {
+      originalContent = await readFile3(absolutePath, "utf-8");
+      existed = true;
+    } catch (error) {
+      console.warn(`[checkpoint] Failed to read file for backup: ${error.message}`);
+    }
+  }
+  const backup = fileBackupQueries.create({
+    checkpointId: manager.currentCheckpointId,
+    sessionId,
+    filePath: relativePath,
+    originalContent,
+    existed
+  });
+  return backup;
+}
+
+// src/tools/write-file.ts
 var writeFileInputSchema = z4.object({
   path: z4.string().describe("The path to the file. Can be relative to working directory or absolute."),
   mode: z4.enum(["full", "str_replace"]).describe('Write mode: "full" for complete file write, "str_replace" for targeted string replacement'),
@@ -663,8 +1210,8 @@ Working directory: ${options.workingDirectory}`,
     inputSchema: writeFileInputSchema,
     execute: async ({ path, mode, content, old_string, new_string }) => {
       try {
-        const absolutePath = isAbsolute2(path) ? path : resolve3(options.workingDirectory, path);
-        const relativePath = relative2(options.workingDirectory, absolutePath);
+        const absolutePath = isAbsolute2(path) ? path : resolve4(options.workingDirectory, path);
+        const relativePath = relative3(options.workingDirectory, absolutePath);
         if (relativePath.startsWith("..") && !isAbsolute2(path)) {
           return {
             success: false,
@@ -678,16 +1225,17 @@ Working directory: ${options.workingDirectory}`,
               error: 'Content is required for "full" mode'
             };
           }
-          const dir = dirname2(absolutePath);
-          if (!existsSync3(dir)) {
-            await mkdir(dir, { recursive: true });
+          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
+          const dir = dirname3(absolutePath);
+          if (!existsSync5(dir)) {
+            await mkdir3(dir, { recursive: true });
           }
-          const existed = existsSync3(absolutePath);
-          await writeFile(absolutePath, content, "utf-8");
+          const existed = existsSync5(absolutePath);
+          await writeFile3(absolutePath, content, "utf-8");
           return {
             success: true,
             path: absolutePath,
-            relativePath: relative2(options.workingDirectory, absolutePath),
+            relativePath: relative3(options.workingDirectory, absolutePath),
             mode: "full",
             action: existed ? "replaced" : "created",
             bytesWritten: Buffer.byteLength(content, "utf-8"),
@@ -700,13 +1248,14 @@ Working directory: ${options.workingDirectory}`,
               error: 'Both old_string and new_string are required for "str_replace" mode'
             };
           }
-          if (!existsSync3(absolutePath)) {
+          if (!existsSync5(absolutePath)) {
             return {
               success: false,
               error: `File not found: ${path}. Use "full" mode to create new files.`
             };
           }
-          const currentContent = await readFile2(absolutePath, "utf-8");
+          await backupFile(options.sessionId, options.workingDirectory, absolutePath);
+          const currentContent = await readFile4(absolutePath, "utf-8");
           if (!currentContent.includes(old_string)) {
             const lines = currentContent.split("\n");
             const preview = lines.slice(0, 20).join("\n");
@@ -727,13 +1276,13 @@ Working directory: ${options.workingDirectory}`,
             };
           }
           const newContent = currentContent.replace(old_string, new_string);
-          await writeFile(absolutePath, newContent, "utf-8");
+          await writeFile3(absolutePath, newContent, "utf-8");
           const oldLines = old_string.split("\n").length;
           const newLines = new_string.split("\n").length;
           return {
             success: true,
             path: absolutePath,
-            relativePath: relative2(options.workingDirectory, absolutePath),
+            relativePath: relative3(options.workingDirectory, absolutePath),
             mode: "str_replace",
             linesRemoved: oldLines,
             linesAdded: newLines,
@@ -884,9 +1433,9 @@ import { tool as tool5 } from "ai";
 import { z as z6 } from "zod";
 
 // src/skills/index.ts
-import { readFile as readFile3, readdir } from "fs/promises";
-import { resolve as resolve4, basename, extname } from "path";
-import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile5, readdir } from "fs/promises";
+import { resolve as resolve5, basename, extname } from "path";
+import { existsSync as existsSync6 } from "fs";
 function parseSkillFrontmatter(content) {
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!frontmatterMatch) {
@@ -917,15 +1466,15 @@ function getSkillNameFromPath(filePath) {
   return basename(filePath, extname(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
 }
 async function loadSkillsFromDirectory(directory) {
-  if (!existsSync4(directory)) {
+  if (!existsSync6(directory)) {
     return [];
   }
   const skills = [];
   const files = await readdir(directory);
   for (const file of files) {
     if (!file.endsWith(".md")) continue;
-    const filePath = resolve4(directory, file);
-    const content = await readFile3(filePath, "utf-8");
+    const filePath = resolve5(directory, file);
+    const content = await readFile5(filePath, "utf-8");
     const parsed = parseSkillFrontmatter(content);
     if (parsed) {
       skills.push({
@@ -967,7 +1516,7 @@ async function loadSkillContent(skillName, directories) {
   if (!skill) {
     return null;
   }
-  const content = await readFile3(skill.filePath, "utf-8");
+  const content = await readFile5(skill.filePath, "utf-8");
   const parsed = parseSkillFrontmatter(content);
   return {
     ...skill,
@@ -1065,460 +1614,21 @@ Once loaded, a skill's content will be available in the conversation context.`,
   });
 }
 
-// src/tools/terminal.ts
-import { tool as tool6 } from "ai";
-import { z as z7 } from "zod";
-
-// src/terminal/manager.ts
-import { spawn } from "child_process";
-import { EventEmitter } from "events";
-var LogBuffer = class {
-  buffer = [];
-  maxSize;
-  totalBytes = 0;
-  maxBytes;
-  constructor(maxBytes = 50 * 1024) {
-    this.maxBytes = maxBytes;
-    this.maxSize = 1e3;
-  }
-  append(data) {
-    const lines = data.split("\n");
-    for (const line of lines) {
-      if (line) {
-        this.buffer.push(line);
-        this.totalBytes += line.length;
-      }
-    }
-    while (this.totalBytes > this.maxBytes && this.buffer.length > 1) {
-      const removed = this.buffer.shift();
-      if (removed) {
-        this.totalBytes -= removed.length;
-      }
-    }
-    while (this.buffer.length > this.maxSize) {
-      const removed = this.buffer.shift();
-      if (removed) {
-        this.totalBytes -= removed.length;
-      }
-    }
-  }
-  getAll() {
-    return this.buffer.join("\n");
-  }
-  getTail(lines) {
-    const start = Math.max(0, this.buffer.length - lines);
-    return this.buffer.slice(start).join("\n");
-  }
-  clear() {
-    this.buffer = [];
-    this.totalBytes = 0;
-  }
-  get lineCount() {
-    return this.buffer.length;
-  }
-};
-var TerminalManager = class _TerminalManager extends EventEmitter {
-  processes = /* @__PURE__ */ new Map();
-  static instance = null;
-  constructor() {
-    super();
-  }
-  static getInstance() {
-    if (!_TerminalManager.instance) {
-      _TerminalManager.instance = new _TerminalManager();
-    }
-    return _TerminalManager.instance;
-  }
-  /**
-   * Spawn a new background process
-   */
-  spawn(options) {
-    const { sessionId, command, cwd, name, env } = options;
-    const parts = this.parseCommand(command);
-    const executable = parts[0];
-    const args = parts.slice(1);
-    const terminal = terminalQueries.create({
-      sessionId,
-      name: name || null,
-      command,
-      cwd: cwd || process.cwd(),
-      status: "running"
-    });
-    const proc = spawn(executable, args, {
-      cwd: cwd || process.cwd(),
-      shell: true,
-      stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env, ...env },
-      detached: false
-    });
-    if (proc.pid) {
-      terminalQueries.updatePid(terminal.id, proc.pid);
-    }
-    const logs = new LogBuffer();
-    proc.stdout?.on("data", (data) => {
-      const text2 = data.toString();
-      logs.append(text2);
-      this.emit("stdout", { terminalId: terminal.id, data: text2 });
-    });
-    proc.stderr?.on("data", (data) => {
-      const text2 = data.toString();
-      logs.append(`[stderr] ${text2}`);
-      this.emit("stderr", { terminalId: terminal.id, data: text2 });
-    });
-    proc.on("exit", (code, signal) => {
-      const exitCode = code ?? (signal ? 128 : 0);
-      terminalQueries.updateStatus(terminal.id, "stopped", exitCode);
-      this.emit("exit", { terminalId: terminal.id, code: exitCode, signal });
-      const managed2 = this.processes.get(terminal.id);
-      if (managed2) {
-        managed2.terminal = { ...managed2.terminal, status: "stopped", exitCode };
-      }
-    });
-    proc.on("error", (err) => {
-      terminalQueries.updateStatus(terminal.id, "error", void 0, err.message);
-      this.emit("error", { terminalId: terminal.id, error: err.message });
-      const managed2 = this.processes.get(terminal.id);
-      if (managed2) {
-        managed2.terminal = { ...managed2.terminal, status: "error", error: err.message };
-      }
-    });
-    const managed = {
-      id: terminal.id,
-      process: proc,
-      logs,
-      terminal: { ...terminal, pid: proc.pid ?? null }
-    };
-    this.processes.set(terminal.id, managed);
-    return this.toTerminalInfo(managed.terminal);
-  }
-  /**
-   * Get logs from a terminal
-   */
-  getLogs(terminalId, tail) {
-    const managed = this.processes.get(terminalId);
-    if (!managed) {
-      return null;
-    }
-    return {
-      logs: tail ? managed.logs.getTail(tail) : managed.logs.getAll(),
-      lineCount: managed.logs.lineCount
-    };
-  }
-  /**
-   * Get terminal status
-   */
-  getStatus(terminalId) {
-    const managed = this.processes.get(terminalId);
-    if (managed) {
-      if (managed.process.exitCode !== null) {
-        managed.terminal = {
-          ...managed.terminal,
-          status: "stopped",
-          exitCode: managed.process.exitCode
-        };
-      }
-      return this.toTerminalInfo(managed.terminal);
-    }
-    const terminal = terminalQueries.getById(terminalId);
-    if (terminal) {
-      return this.toTerminalInfo(terminal);
-    }
-    return null;
-  }
-  /**
-   * Kill a terminal process
-   */
-  kill(terminalId, signal = "SIGTERM") {
-    const managed = this.processes.get(terminalId);
-    if (!managed) {
-      return false;
-    }
-    try {
-      managed.process.kill(signal);
-      return true;
-    } catch (err) {
-      console.error(`Failed to kill terminal ${terminalId}:`, err);
-      return false;
-    }
-  }
-  /**
-   * Write to a terminal's stdin
-   */
-  write(terminalId, input) {
-    const managed = this.processes.get(terminalId);
-    if (!managed || !managed.process.stdin) {
-      return false;
-    }
-    try {
-      managed.process.stdin.write(input);
-      return true;
-    } catch (err) {
-      console.error(`Failed to write to terminal ${terminalId}:`, err);
-      return false;
-    }
-  }
-  /**
-   * List all terminals for a session
-   */
-  list(sessionId) {
-    const terminals2 = terminalQueries.getBySession(sessionId);
-    return terminals2.map((t) => {
-      const managed = this.processes.get(t.id);
-      if (managed) {
-        return this.toTerminalInfo(managed.terminal);
-      }
-      return this.toTerminalInfo(t);
-    });
-  }
-  /**
-   * Get all running terminals for a session
-   */
-  getRunning(sessionId) {
-    return this.list(sessionId).filter((t) => t.status === "running");
-  }
-  /**
-   * Kill all terminals for a session (cleanup)
-   */
-  killAll(sessionId) {
-    let killed = 0;
-    for (const [id, managed] of this.processes) {
-      if (managed.terminal.sessionId === sessionId) {
-        if (this.kill(id)) {
-          killed++;
-        }
-      }
-    }
-    return killed;
-  }
-  /**
-   * Clean up stopped terminals from memory (keep DB records)
-   */
-  cleanup(sessionId) {
-    let cleaned = 0;
-    for (const [id, managed] of this.processes) {
-      if (sessionId && managed.terminal.sessionId !== sessionId) {
-        continue;
-      }
-      if (managed.terminal.status !== "running") {
-        this.processes.delete(id);
-        cleaned++;
-      }
-    }
-    return cleaned;
-  }
-  /**
-   * Parse a command string into executable and arguments
-   */
-  parseCommand(command) {
-    const parts = [];
-    let current = "";
-    let inQuote = false;
-    let quoteChar = "";
-    for (const char of command) {
-      if ((char === '"' || char === "'") && !inQuote) {
-        inQuote = true;
-        quoteChar = char;
-      } else if (char === quoteChar && inQuote) {
-        inQuote = false;
-        quoteChar = "";
-      } else if (char === " " && !inQuote) {
-        if (current) {
-          parts.push(current);
-          current = "";
-        }
-      } else {
-        current += char;
-      }
-    }
-    if (current) {
-      parts.push(current);
-    }
-    return parts.length > 0 ? parts : [command];
-  }
-  toTerminalInfo(terminal) {
-    return {
-      id: terminal.id,
-      name: terminal.name,
-      command: terminal.command,
-      cwd: terminal.cwd,
-      pid: terminal.pid,
-      status: terminal.status,
-      exitCode: terminal.exitCode,
-      error: terminal.error,
-      createdAt: terminal.createdAt,
-      stoppedAt: terminal.stoppedAt
-    };
-  }
-};
-function getTerminalManager() {
-  return TerminalManager.getInstance();
-}
-
-// src/tools/terminal.ts
-var TerminalInputSchema = z7.object({
-  action: z7.enum(["spawn", "logs", "status", "kill", "write", "list"]).describe(
-    "The action to perform: spawn (start process), logs (get output), status (check if running), kill (stop process), write (send stdin), list (show all)"
-  ),
-  // For spawn
-  command: z7.string().optional().describe('For spawn: The command to run (e.g., "npm run dev")'),
-  cwd: z7.string().optional().describe("For spawn: Working directory for the command"),
-  name: z7.string().optional().describe('For spawn: Optional friendly name (e.g., "dev-server")'),
-  // For logs, status, kill, write
-  terminalId: z7.string().optional().describe("For logs/status/kill/write: The terminal ID"),
-  tail: z7.number().optional().describe("For logs: Number of lines to return from the end"),
-  // For kill
-  signal: z7.enum(["SIGTERM", "SIGKILL"]).optional().describe("For kill: Signal to send (default: SIGTERM)"),
-  // For write
-  input: z7.string().optional().describe("For write: The input to send to stdin")
-});
-function createTerminalTool(options) {
-  const { sessionId, workingDirectory } = options;
-  return tool6({
-    description: `Manage background terminal processes. Use this for long-running commands like dev servers, watchers, or any process that shouldn't block.
-
-Actions:
-- spawn: Start a new background process. Requires 'command'. Returns terminal ID.
-- logs: Get output from a terminal. Requires 'terminalId'. Optional 'tail' for recent lines.
-- status: Check if a terminal is still running. Requires 'terminalId'.
-- kill: Stop a terminal process. Requires 'terminalId'. Optional 'signal'.
-- write: Send input to a terminal's stdin. Requires 'terminalId' and 'input'.
-- list: Show all terminals for this session. No other params needed.
-
-Example workflow:
-1. spawn with command="npm run dev", name="dev-server" \u2192 { id: "abc123", status: "running" }
-2. logs with terminalId="abc123", tail=10 \u2192 "Ready on http://localhost:3000"
-3. kill with terminalId="abc123" \u2192 { success: true }`,
-    inputSchema: TerminalInputSchema,
-    execute: async (input) => {
-      const manager = getTerminalManager();
-      switch (input.action) {
-        case "spawn": {
-          if (!input.command) {
-            return { success: false, error: 'spawn requires a "command" parameter' };
-          }
-          const terminal = manager.spawn({
-            sessionId,
-            command: input.command,
-            cwd: input.cwd || workingDirectory,
-            name: input.name
-          });
-          return {
-            success: true,
-            terminal: formatTerminal(terminal),
-            message: `Started "${input.command}" with terminal ID: ${terminal.id}`
-          };
-        }
-        case "logs": {
-          if (!input.terminalId) {
-            return { success: false, error: 'logs requires a "terminalId" parameter' };
-          }
-          const result = manager.getLogs(input.terminalId, input.tail);
-          if (!result) {
-            return {
-              success: false,
-              error: `Terminal not found: ${input.terminalId}`
-            };
-          }
-          return {
-            success: true,
-            terminalId: input.terminalId,
-            logs: result.logs,
-            lineCount: result.lineCount
-          };
-        }
-        case "status": {
-          if (!input.terminalId) {
-            return { success: false, error: 'status requires a "terminalId" parameter' };
-          }
-          const status = manager.getStatus(input.terminalId);
-          if (!status) {
-            return {
-              success: false,
-              error: `Terminal not found: ${input.terminalId}`
-            };
-          }
-          return {
-            success: true,
-            terminal: formatTerminal(status)
-          };
-        }
-        case "kill": {
-          if (!input.terminalId) {
-            return { success: false, error: 'kill requires a "terminalId" parameter' };
-          }
-          const success = manager.kill(input.terminalId, input.signal);
-          if (!success) {
-            return {
-              success: false,
-              error: `Failed to kill terminal: ${input.terminalId}`
-            };
-          }
-          return {
-            success: true,
-            message: `Sent ${input.signal || "SIGTERM"} to terminal ${input.terminalId}`
-          };
-        }
-        case "write": {
-          if (!input.terminalId) {
-            return { success: false, error: 'write requires a "terminalId" parameter' };
-          }
-          if (!input.input) {
-            return { success: false, error: 'write requires an "input" parameter' };
-          }
-          const success = manager.write(input.terminalId, input.input);
-          if (!success) {
-            return {
-              success: false,
-              error: `Failed to write to terminal: ${input.terminalId}`
-            };
-          }
-          return {
-            success: true,
-            message: `Sent input to terminal ${input.terminalId}`
-          };
-        }
-        case "list": {
-          const terminals2 = manager.list(sessionId);
-          return {
-            success: true,
-            terminals: terminals2.map(formatTerminal),
-            count: terminals2.length,
-            running: terminals2.filter((t) => t.status === "running").length
-          };
-        }
-        default:
-          return { success: false, error: `Unknown action: ${input.action}` };
-      }
-    }
-  });
-}
-function formatTerminal(t) {
-  return {
-    id: t.id,
-    name: t.name,
-    command: t.command,
-    cwd: t.cwd,
-    pid: t.pid,
-    status: t.status,
-    exitCode: t.exitCode,
-    error: t.error,
-    createdAt: t.createdAt.toISOString(),
-    stoppedAt: t.stoppedAt?.toISOString() || null
-  };
-}
-
 // src/tools/index.ts
 function createTools(options) {
   return {
     bash: createBashTool({
       workingDirectory: options.workingDirectory,
-      onOutput: options.onBashOutput
+      sessionId: options.sessionId,
+      onOutput: options.onBashOutput,
+      onProgress: options.onBashProgress
     }),
     read_file: createReadFileTool({
       workingDirectory: options.workingDirectory
     }),
     write_file: createWriteFileTool({
-      workingDirectory: options.workingDirectory
+      workingDirectory: options.workingDirectory,
+      sessionId: options.sessionId
     }),
     todo: createTodoTool({
       sessionId: options.sessionId
@@ -1526,10 +1636,6 @@ function createTools(options) {
     load_skill: createLoadSkillTool({
       sessionId: options.sessionId,
       skillsDirectories: options.skillsDirectories
-    }),
-    terminal: createTerminalTool({
-      sessionId: options.sessionId,
-      workingDirectory: options.workingDirectory
     })
   };
 }
@@ -1539,25 +1645,102 @@ import { generateText } from "ai";
 import { gateway } from "@ai-sdk/gateway";
 
 // src/agent/prompts.ts
+import os from "os";
+function getSearchInstructions() {
+  const platform2 = process.platform;
+  const common = `- **Prefer \`read_file\` over shell commands** for reading files - don't use \`cat\`, \`head\`, or \`tail\` when \`read_file\` is available
+- **Avoid unbounded searches** - always scope searches with glob patterns and directory paths to prevent overwhelming output
+- **Search strategically**: Start with specific patterns and directories, then broaden only if needed`;
+  if (platform2 === "win32") {
+    return `${common}
+- **Find files**: \`dir /s /b *.ts\` or PowerShell: \`Get-ChildItem -Recurse -Filter *.ts\`
+- **Search content**: \`findstr /s /n "pattern" *.ts\` or PowerShell: \`Select-String -Pattern "pattern" -Path *.ts -Recurse\`
+- **If ripgrep (\`rg\`) is installed**: \`rg "pattern" -t ts src/\` - faster and respects .gitignore`;
+  }
+  return `${common}
+- **Find files**: \`find . -name "*.ts"\` or \`find src/ -type f -name "*.tsx"\`
+- **Search content**: \`grep -rn "pattern" --include="*.ts" src/\` - use \`-l\` for filenames only, \`-c\` for counts
+- **If ripgrep (\`rg\`) is installed**: \`rg "pattern" -t ts src/\` - faster and respects .gitignore`;
+}
 async function buildSystemPrompt(options) {
   const { workingDirectory, skillsDirectories, sessionId, customInstructions } = options;
   const skills = await loadAllSkills(skillsDirectories);
   const skillsContext = formatSkillsForContext(skills);
   const todos = todoQueries.getBySession(sessionId);
   const todosContext = formatTodosForContext(todos);
-  const systemPrompt = `You are Sparkecoder, an expert AI coding assistant. You help developers write, debug, and improve code.
+  const platform2 = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
+  const currentDate = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+  const searchInstructions = getSearchInstructions();
+  const systemPrompt = `You are SparkECoder, an expert AI coding assistant. You help developers write, debug, and improve code.
 
-## Working Directory
-You are working in: ${workingDirectory}
+## Environment
+- **Platform**: ${platform2} (${os.release()})
+- **Date**: ${currentDate}
+- **Working Directory**: ${workingDirectory}
 
 ## Core Capabilities
 You have access to powerful tools for:
-- **bash**: Execute shell commands, run scripts, install packages, use git
+- **bash**: Execute commands in the terminal (see below for details)
 - **read_file**: Read file contents to understand code and context
 - **write_file**: Create new files or edit existing ones (supports targeted string replacement)
 - **todo**: Manage your task list to track progress on complex operations
 - **load_skill**: Load specialized knowledge documents for specific tasks
 
+
+IMPORTANT: If you have zero context of where you are working, always explore it first to understand the structure before doing things for the user.
+
+Use the TODO tool to manage your task list to track progress on complex operations. Always ask the user what they want to do specifically before doing it, and make a plan. 
+Step 1 of the plan should be researching files and understanding the components/structure of what you're working on (if you don't already have context), then after u have done that, plan out the rest of the tasks u need to do. 
+You can clear the todo and restart it, and do multiple things inside of one session.
+
+### bash Tool
+The bash tool runs commands in the terminal. Every command runs in its own session with logs saved to disk.
+
+**Run a command (default - waits for completion):**
+\`\`\`
+bash({ command: "npm install" })
+bash({ command: "git status" })
+\`\`\`
+
+**Run in background (for dev servers, watchers):**
+\`\`\`
+bash({ command: "npm run dev", background: true })
+\u2192 Returns { id: "abc123" } - save this ID to check logs or stop it later
+\`\`\`
+
+**Check on a background process:**
+\`\`\`
+bash({ id: "abc123" })              // get full output
+bash({ id: "abc123", tail: 50 })    // last 50 lines only
+\`\`\`
+
+**Stop a background process:**
+\`\`\`
+bash({ id: "abc123", kill: true })
+\`\`\`
+
+**Respond to interactive prompts (for yes/no questions, etc.):**
+\`\`\`
+bash({ id: "abc123", key: "y" })      // send 'y' for yes
+bash({ id: "abc123", key: "n" })      // send 'n' for no  
+bash({ id: "abc123", key: "Enter" })  // press Enter
+bash({ id: "abc123", input: "my text" })  // send text input
+\`\`\`
+
+**IMPORTANT - Handling Interactive Commands:**
+- ALWAYS prefer non-interactive flags when available:
+  - \`npm init --yes\` or \`npm install --yes\`
+  - \`npx create-next-app --yes\` (accepts all defaults)
+  - \`npx create-react-app --yes\`
+  - \`git commit --no-edit\`
+  - \`apt-get install -y\`
+- If a command might prompt for input, run it in background mode first
+- Check the output to see if it's waiting for input
+- Use \`key: "y"\` or \`key: "n"\` for yes/no prompts
+- Use \`input: "text"\` for text input prompts
+
+Logs are saved to \`.sparkecoder/terminals/{id}/output.log\` and can be read with \`read_file\` if needed.
+
 ## Guidelines
 
 ### Code Quality
@@ -1578,6 +1761,30 @@ You have access to powerful tools for:
 - Use \`write_file\` with mode "full" only for new files or complete rewrites
 - Always verify changes by reading files after modifications
 
+### Searching and Exploration
+${searchInstructions}
+
+Follow these principles when designing and implementing software:
+
+1. **Modularity** \u2014 Write simple parts connected by clean interfaces
+2. **Clarity** \u2014 Clarity is better than cleverness
+3. **Composition** \u2014 Design programs to be connected to other programs
+4. **Separation** \u2014 Separate policy from mechanism; separate interfaces from engines
+5. **Simplicity** \u2014 Design for simplicity; add complexity only where you must
+6. **Parsimony** \u2014 Write a big program only when it is clear by demonstration that nothing else will do
+7. **Transparency** \u2014 Design for visibility to make inspection and debugging easier
+8. **Robustness** \u2014 Robustness is the child of transparency and simplicity
+9. **Representation** \u2014 Fold knowledge into data so program logic can be stupid and robust
+10. **Least Surprise** \u2014 In interface design, always do the least surprising thing
+11. **Silence** \u2014 When a program has nothing surprising to say, it should say nothing
+12. **Repair** \u2014 When you must fail, fail noisily and as soon as possible
+13. **Economy** \u2014 Programmer time is expensive; conserve it in preference to machine time
+14. **Generation** \u2014 Avoid hand-hacking; write programs to write programs when you can
+15. **Optimization** \u2014 Prototype before polishing. Get it working before you optimize it
+16. **Diversity** \u2014 Distrust all claims for "one true way"
+17. **Extensibility** \u2014 Design for the future, because it will be here sooner than you think
+
+
 ### Communication
 - Explain your reasoning and approach
 - Be concise but thorough
@@ -1734,12 +1941,24 @@ var approvalResolvers = /* @__PURE__ */ new Map();
 var Agent = class _Agent {
   session;
   context;
-  tools;
+  baseTools;
   pendingApprovals = /* @__PURE__ */ new Map();
   constructor(session, context, tools) {
     this.session = session;
     this.context = context;
-    this.tools = tools;
+    this.baseTools = tools;
+  }
+  /**
+   * Create tools with optional progress callbacks
+   */
+  createToolsWithCallbacks(options) {
+    const config = getConfig();
+    return createTools({
+      sessionId: this.session.id,
+      workingDirectory: this.session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories,
+      onBashProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "bash", data: progress }) : void 0
+    });
   }
   /**
    * Create or resume an agent session
@@ -1791,7 +2010,9 @@ var Agent = class _Agent {
    */
   async stream(options) {
     const config = getConfig();
-    this.context.addUserMessage(options.prompt);
+    if (!options.skipSaveUserMessage) {
+      this.context.addUserMessage(options.prompt);
+    }
     sessionQueries.updateStatus(this.session.id, "active");
     const systemPrompt = await buildSystemPrompt({
       workingDirectory: this.session.workingDirectory,
@@ -1799,15 +2020,30 @@ var Agent = class _Agent {
       sessionId: this.session.id
     });
     const messages2 = await this.context.getMessages();
-    const wrappedTools = this.wrapToolsWithApproval(options);
+    const tools = options.onToolProgress ? this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
+    const wrappedTools = this.wrapToolsWithApproval(options, tools);
     const stream = streamText({
       model: gateway2(this.session.model),
       system: systemPrompt,
       messages: messages2,
       tools: wrappedTools,
-      stopWhen: stepCountIs(20),
+      stopWhen: stepCountIs(500),
+      // Forward abort signal if provided
+      abortSignal: options.abortSignal,
+      // Enable extended thinking/reasoning for models that support it
+      providerOptions: {
+        anthropic: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 1e4
+          }
+        }
+      },
       onStepFinish: async (step) => {
         options.onStepFinish?.(step);
+      },
+      onAbort: ({ steps }) => {
+        options.onAbort?.({ steps });
       }
     });
     const saveResponseMessages = async () => {
@@ -1835,13 +2071,23 @@ var Agent = class _Agent {
       sessionId: this.session.id
     });
     const messages2 = await this.context.getMessages();
-    const wrappedTools = this.wrapToolsWithApproval(options);
+    const tools = options.onToolProgress ? this.createToolsWithCallbacks({ onToolProgress: options.onToolProgress }) : this.baseTools;
+    const wrappedTools = this.wrapToolsWithApproval(options, tools);
     const result = await generateText2({
       model: gateway2(this.session.model),
       system: systemPrompt,
       messages: messages2,
       tools: wrappedTools,
-      stopWhen: stepCountIs(20)
+      stopWhen: stepCountIs(500),
+      // Enable extended thinking/reasoning for models that support it
+      providerOptions: {
+        anthropic: {
+          thinking: {
+            type: "enabled",
+            budgetTokens: 1e4
+          }
+        }
+      }
     });
     const responseMessages = result.response.messages;
     this.context.addResponseMessages(responseMessages);
@@ -1853,20 +2099,21 @@ var Agent = class _Agent {
   /**
    * Wrap tools to add approval checking
    */
-  wrapToolsWithApproval(options) {
+  wrapToolsWithApproval(options, tools) {
     const sessionConfig = this.session.config;
     const wrappedTools = {};
-    for (const [name, originalTool] of Object.entries(this.tools)) {
+    const toolsToWrap = tools || this.baseTools;
+    for (const [name, originalTool] of Object.entries(toolsToWrap)) {
       const needsApproval = requiresApproval(name, sessionConfig ?? void 0);
       if (!needsApproval) {
         wrappedTools[name] = originalTool;
         continue;
       }
-      wrappedTools[name] = tool7({
+      wrappedTools[name] = tool6({
         description: originalTool.description || "",
-        inputSchema: originalTool.inputSchema || z8.object({}),
+        inputSchema: originalTool.inputSchema || z7.object({}),
         execute: async (input, toolOptions) => {
-          const toolCallId = toolOptions.toolCallId || nanoid2();
+          const toolCallId = toolOptions.toolCallId || nanoid3();
           const execution = toolExecutionQueries.create({
             sessionId: this.session.id,
             toolName: name,
@@ -1878,8 +2125,8 @@ var Agent = class _Agent {
           this.pendingApprovals.set(toolCallId, execution);
           options.onApprovalRequired?.(execution);
           sessionQueries.updateStatus(this.session.id, "waiting");
-          const approved = await new Promise((resolve5) => {
-            approvalResolvers.set(toolCallId, { resolve: resolve5, sessionId: this.session.id });
+          const approved = await new Promise((resolve6) => {
+            approvalResolvers.set(toolCallId, { resolve: resolve6, sessionId: this.session.id });
           });
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);