sparkecoder 0.1.3

package/dist/server/index.js

@@ -0,0 +1,3458 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/server/index.ts
+import { Hono as Hono5 } from "hono";
+import { serve } from "@hono/node-server";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import { existsSync as existsSync5, mkdirSync } from "fs";
+
+// src/server/routes/sessions.ts
+import { Hono } from "hono";
+import { zValidator } from "@hono/zod-validator";
+import { z as z9 } from "zod";
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { eq, desc, and, sql } from "drizzle-orm";
+import { nanoid } from "nanoid";
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  loadedSkills: () => loadedSkills,
+  messages: () => messages,
+  sessions: () => sessions,
+  terminals: () => terminals,
+  todoItems: () => todoItems,
+  toolExecutions: () => toolExecutions
+});
+import { sqliteTable, text, integer } from "drizzle-orm/sqlite-core";
+var sessions = sqliteTable("sessions", {
+  id: text("id").primaryKey(),
+  name: text("name"),
+  workingDirectory: text("working_directory").notNull(),
+  model: text("model").notNull(),
+  status: text("status", { enum: ["active", "waiting", "completed", "error"] }).notNull().default("active"),
+  config: text("config", { mode: "json" }).$type(),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var messages = sqliteTable("messages", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  // Store the entire ModelMessage as JSON (role + content)
+  modelMessage: text("model_message", { mode: "json" }).$type().notNull(),
+  // Sequence number within session to maintain exact ordering
+  sequence: integer("sequence").notNull().default(0),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var toolExecutions = sqliteTable("tool_executions", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  messageId: text("message_id").references(() => messages.id, { onDelete: "cascade" }),
+  toolName: text("tool_name").notNull(),
+  toolCallId: text("tool_call_id").notNull(),
+  input: text("input", { mode: "json" }),
+  output: text("output", { mode: "json" }),
+  status: text("status", { enum: ["pending", "approved", "rejected", "completed", "error"] }).notNull().default("pending"),
+  requiresApproval: integer("requires_approval", { mode: "boolean" }).notNull().default(false),
+  error: text("error"),
+  startedAt: integer("started_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  completedAt: integer("completed_at", { mode: "timestamp" })
+});
+var todoItems = sqliteTable("todo_items", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  content: text("content").notNull(),
+  status: text("status", { enum: ["pending", "in_progress", "completed", "cancelled"] }).notNull().default("pending"),
+  order: integer("order").notNull().default(0),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var loadedSkills = sqliteTable("loaded_skills", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  skillName: text("skill_name").notNull(),
+  loadedAt: integer("loaded_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date())
+});
+var terminals = sqliteTable("terminals", {
+  id: text("id").primaryKey(),
+  sessionId: text("session_id").notNull().references(() => sessions.id, { onDelete: "cascade" }),
+  name: text("name"),
+  // Optional friendly name (e.g., "dev-server")
+  command: text("command").notNull(),
+  // The command that was run
+  cwd: text("cwd").notNull(),
+  // Working directory
+  pid: integer("pid"),
+  // Process ID (null if not running)
+  status: text("status", { enum: ["running", "stopped", "error"] }).notNull().default("running"),
+  exitCode: integer("exit_code"),
+  // Exit code if stopped
+  error: text("error"),
+  // Error message if status is 'error'
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull().$defaultFn(() => /* @__PURE__ */ new Date()),
+  stoppedAt: integer("stopped_at", { mode: "timestamp" })
+});
+
+// src/db/index.ts
+var db = null;
+var sqlite = null;
+function initDatabase(dbPath) {
+  sqlite = new Database(dbPath);
+  sqlite.pragma("journal_mode = WAL");
+  db = drizzle(sqlite, { schema: schema_exports });
+  sqlite.exec(`
+    DROP TABLE IF EXISTS terminals;
+    DROP TABLE IF EXISTS loaded_skills;
+    DROP TABLE IF EXISTS todo_items;
+    DROP TABLE IF EXISTS tool_executions;
+    DROP TABLE IF EXISTS messages;
+    DROP TABLE IF EXISTS sessions;
+
+    CREATE TABLE sessions (
+      id TEXT PRIMARY KEY,
+      name TEXT,
+      working_directory TEXT NOT NULL,
+      model TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active',
+      config TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE messages (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      model_message TEXT NOT NULL,
+      sequence INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE tool_executions (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      message_id TEXT REFERENCES messages(id) ON DELETE CASCADE,
+      tool_name TEXT NOT NULL,
+      tool_call_id TEXT NOT NULL,
+      input TEXT,
+      output TEXT,
+      status TEXT NOT NULL DEFAULT 'pending',
+      requires_approval INTEGER NOT NULL DEFAULT 0,
+      error TEXT,
+      started_at INTEGER NOT NULL,
+      completed_at INTEGER
+    );
+
+    CREATE TABLE todo_items (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      "order" INTEGER NOT NULL DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE loaded_skills (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      skill_name TEXT NOT NULL,
+      loaded_at INTEGER NOT NULL
+    );
+
+    CREATE TABLE terminals (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+      name TEXT,
+      command TEXT NOT NULL,
+      cwd TEXT NOT NULL,
+      pid INTEGER,
+      status TEXT NOT NULL DEFAULT 'running',
+      exit_code INTEGER,
+      error TEXT,
+      created_at INTEGER NOT NULL,
+      stopped_at INTEGER
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+    CREATE INDEX IF NOT EXISTS idx_tool_executions_session ON tool_executions(session_id);
+    CREATE INDEX IF NOT EXISTS idx_todo_items_session ON todo_items(session_id);
+    CREATE INDEX IF NOT EXISTS idx_loaded_skills_session ON loaded_skills(session_id);
+    CREATE INDEX IF NOT EXISTS idx_terminals_session ON terminals(session_id);
+  `);
+  return db;
+}
+function getDb() {
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase first.");
+  }
+  return db;
+}
+function closeDatabase() {
+  if (sqlite) {
+    sqlite.close();
+    sqlite = null;
+    db = null;
+  }
+}
+var sessionQueries = {
+  create(data) {
+    const id = nanoid();
+    const now = /* @__PURE__ */ new Date();
+    const result = getDb().insert(sessions).values({
+      id,
+      ...data,
+      createdAt: now,
+      updatedAt: now
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(sessions).where(eq(sessions.id, id)).get();
+  },
+  list(limit = 50, offset = 0) {
+    return getDb().select().from(sessions).orderBy(desc(sessions.createdAt)).limit(limit).offset(offset).all();
+  },
+  updateStatus(id, status) {
+    return getDb().update(sessions).set({ status, 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;
+  }
+};
+var messageQueries = {
+  /**
+   * Get the next sequence number for a session
+   */
+  getNextSequence(sessionId) {
+    const result = getDb().select({ maxSeq: sql`COALESCE(MAX(sequence), -1)` }).from(messages).where(eq(messages.sessionId, sessionId)).get();
+    return (result?.maxSeq ?? -1) + 1;
+  },
+  /**
+   * Create a single message from a ModelMessage
+   */
+  create(sessionId, modelMessage) {
+    const id = nanoid();
+    const sequence = this.getNextSequence(sessionId);
+    const result = getDb().insert(messages).values({
+      id,
+      sessionId,
+      modelMessage,
+      sequence,
+      createdAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  /**
+   * Add multiple ModelMessages at once (from response.messages)
+   * Maintains insertion order via sequence numbers
+   */
+  addMany(sessionId, modelMessages) {
+    const results = [];
+    let sequence = this.getNextSequence(sessionId);
+    for (const msg of modelMessages) {
+      const id = nanoid();
+      const result = getDb().insert(messages).values({
+        id,
+        sessionId,
+        modelMessage: msg,
+        sequence,
+        createdAt: /* @__PURE__ */ new Date()
+      }).returning().get();
+      results.push(result);
+      sequence++;
+    }
+    return results;
+  },
+  /**
+   * Get all messages for a session as ModelMessage[]
+   * Ordered by sequence to maintain exact insertion order
+   */
+  getBySession(sessionId) {
+    return getDb().select().from(messages).where(eq(messages.sessionId, sessionId)).orderBy(messages.sequence).all();
+  },
+  /**
+   * Get ModelMessages directly (for passing to AI SDK)
+   */
+  getModelMessages(sessionId) {
+    const messages2 = this.getBySession(sessionId);
+    return messages2.map((m) => m.modelMessage);
+  },
+  getRecentBySession(sessionId, limit = 50) {
+    return getDb().select().from(messages).where(eq(messages.sessionId, sessionId)).orderBy(desc(messages.sequence)).limit(limit).all().reverse();
+  },
+  countBySession(sessionId) {
+    const result = getDb().select({ count: sql`count(*)` }).from(messages).where(eq(messages.sessionId, sessionId)).get();
+    return result?.count ?? 0;
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(messages).where(eq(messages.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+var toolExecutionQueries = {
+  create(data) {
+    const id = nanoid();
+    const result = getDb().insert(toolExecutions).values({
+      id,
+      ...data,
+      startedAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(toolExecutions).where(eq(toolExecutions.id, id)).get();
+  },
+  getByToolCallId(toolCallId) {
+    return getDb().select().from(toolExecutions).where(eq(toolExecutions.toolCallId, toolCallId)).get();
+  },
+  getPendingApprovals(sessionId) {
+    return getDb().select().from(toolExecutions).where(
+      and(
+        eq(toolExecutions.sessionId, sessionId),
+        eq(toolExecutions.status, "pending"),
+        eq(toolExecutions.requiresApproval, true)
+      )
+    ).all();
+  },
+  approve(id) {
+    return getDb().update(toolExecutions).set({ status: "approved" }).where(eq(toolExecutions.id, id)).returning().get();
+  },
+  reject(id) {
+    return getDb().update(toolExecutions).set({ status: "rejected" }).where(eq(toolExecutions.id, id)).returning().get();
+  },
+  complete(id, output, error) {
+    return getDb().update(toolExecutions).set({
+      status: error ? "error" : "completed",
+      output,
+      error,
+      completedAt: /* @__PURE__ */ new Date()
+    }).where(eq(toolExecutions.id, id)).returning().get();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(toolExecutions).where(eq(toolExecutions.sessionId, sessionId)).orderBy(toolExecutions.startedAt).all();
+  }
+};
+var todoQueries = {
+  create(data) {
+    const id = nanoid();
+    const now = /* @__PURE__ */ new Date();
+    const result = getDb().insert(todoItems).values({
+      id,
+      ...data,
+      createdAt: now,
+      updatedAt: now
+    }).returning().get();
+    return result;
+  },
+  createMany(sessionId, items) {
+    const now = /* @__PURE__ */ new Date();
+    const values = items.map((item, index) => ({
+      id: nanoid(),
+      sessionId,
+      content: item.content,
+      order: item.order ?? index,
+      createdAt: now,
+      updatedAt: now
+    }));
+    return getDb().insert(todoItems).values(values).returning().all();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(todoItems).where(eq(todoItems.sessionId, sessionId)).orderBy(todoItems.order).all();
+  },
+  updateStatus(id, status) {
+    return getDb().update(todoItems).set({ status, updatedAt: /* @__PURE__ */ new Date() }).where(eq(todoItems.id, id)).returning().get();
+  },
+  delete(id) {
+    const result = getDb().delete(todoItems).where(eq(todoItems.id, id)).run();
+    return result.changes > 0;
+  },
+  clearSession(sessionId) {
+    const result = getDb().delete(todoItems).where(eq(todoItems.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+var skillQueries = {
+  load(sessionId, skillName) {
+    const id = nanoid();
+    const result = getDb().insert(loadedSkills).values({
+      id,
+      sessionId,
+      skillName,
+      loadedAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(loadedSkills).where(eq(loadedSkills.sessionId, sessionId)).orderBy(loadedSkills.loadedAt).all();
+  },
+  isLoaded(sessionId, skillName) {
+    const result = getDb().select().from(loadedSkills).where(
+      and(
+        eq(loadedSkills.sessionId, sessionId),
+        eq(loadedSkills.skillName, skillName)
+      )
+    ).get();
+    return !!result;
+  }
+};
+var terminalQueries = {
+  create(data) {
+    const id = nanoid();
+    const result = getDb().insert(terminals).values({
+      id,
+      ...data,
+      createdAt: /* @__PURE__ */ new Date()
+    }).returning().get();
+    return result;
+  },
+  getById(id) {
+    return getDb().select().from(terminals).where(eq(terminals.id, id)).get();
+  },
+  getBySession(sessionId) {
+    return getDb().select().from(terminals).where(eq(terminals.sessionId, sessionId)).orderBy(desc(terminals.createdAt)).all();
+  },
+  getRunning(sessionId) {
+    return getDb().select().from(terminals).where(
+      and(
+        eq(terminals.sessionId, sessionId),
+        eq(terminals.status, "running")
+      )
+    ).all();
+  },
+  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;
+  },
+  deleteBySession(sessionId) {
+    const result = getDb().delete(terminals).where(eq(terminals.sessionId, sessionId)).run();
+    return result.changes;
+  }
+};
+
+// src/agent/index.ts
+import {
+  streamText,
+  generateText as generateText2,
+  tool as tool7,
+  stepCountIs
+} from "ai";
+import { gateway as gateway2 } from "@ai-sdk/gateway";
+import { z as z8 } from "zod";
+import { nanoid as nanoid2 } from "nanoid";
+
+// src/config/index.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve, dirname } from "path";
+
+// src/config/types.ts
+import { z } from "zod";
+var ToolApprovalConfigSchema = z.object({
+  bash: z.boolean().optional().default(true),
+  write_file: z.boolean().optional().default(false),
+  read_file: z.boolean().optional().default(false),
+  load_skill: z.boolean().optional().default(false),
+  todo: z.boolean().optional().default(false)
+});
+var SkillMetadataSchema = z.object({
+  name: z.string(),
+  description: z.string()
+});
+var SessionConfigSchema = z.object({
+  toolApprovals: z.record(z.string(), z.boolean()).optional(),
+  approvalWebhook: z.string().url().optional(),
+  skillsDirectory: z.string().optional(),
+  maxContextChars: z.number().optional().default(2e5)
+});
+var SparkcoderConfigSchema = z.object({
+  // Default model to use (Vercel AI Gateway format)
+  defaultModel: z.string().default("anthropic/claude-opus-4-5"),
+  // Working directory for file operations
+  workingDirectory: z.string().optional(),
+  // Tool approval settings
+  toolApprovals: ToolApprovalConfigSchema.optional().default({}),
+  // Approval webhook URL (called when approval is needed)
+  approvalWebhook: z.string().url().optional(),
+  // Skills configuration
+  skills: z.object({
+    // Directory containing skill files
+    directory: z.string().optional().default("./skills"),
+    // Additional skill directories to include
+    additionalDirectories: z.array(z.string()).optional().default([])
+  }).optional().default({}),
+  // Context management
+  context: z.object({
+    // Maximum context size before summarization (in characters)
+    maxChars: z.number().optional().default(2e5),
+    // Enable automatic summarization
+    autoSummarize: z.boolean().optional().default(true),
+    // Number of recent messages to keep after summarization
+    keepRecentMessages: z.number().optional().default(10)
+  }).optional().default({}),
+  // Server configuration
+  server: z.object({
+    port: z.number().default(3141),
+    host: z.string().default("127.0.0.1")
+  }).default({ port: 3141, host: "127.0.0.1" }),
+  // Database path
+  databasePath: z.string().optional().default("./sparkecoder.db")
+});
+
+// src/config/index.ts
+var CONFIG_FILE_NAMES = [
+  "sparkecoder.config.json",
+  "sparkecoder.json",
+  ".sparkecoder.json"
+];
+var cachedConfig = null;
+function findConfigFile(startDir) {
+  let currentDir = startDir;
+  while (currentDir !== dirname(currentDir)) {
+    for (const fileName of CONFIG_FILE_NAMES) {
+      const configPath = resolve(currentDir, fileName);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    currentDir = dirname(currentDir);
+  }
+  return null;
+}
+function loadConfig(configPath, workingDirectory) {
+  const cwd = workingDirectory || process.cwd();
+  let rawConfig = {};
+  let configDir = cwd;
+  if (configPath) {
+    if (!existsSync(configPath)) {
+      throw new Error(`Config file not found: ${configPath}`);
+    }
+    const content = readFileSync(configPath, "utf-8");
+    rawConfig = JSON.parse(content);
+    configDir = dirname(resolve(configPath));
+  } else {
+    const foundPath = findConfigFile(cwd);
+    if (foundPath) {
+      const content = readFileSync(foundPath, "utf-8");
+      rawConfig = JSON.parse(content);
+      configDir = dirname(foundPath);
+    }
+  }
+  if (process.env.SPARKECODER_MODEL) {
+    rawConfig.defaultModel = process.env.SPARKECODER_MODEL;
+  }
+  if (process.env.SPARKECODER_PORT) {
+    rawConfig.server = {
+      port: parseInt(process.env.SPARKECODER_PORT, 10),
+      host: rawConfig.server?.host ?? "127.0.0.1"
+    };
+  }
+  if (process.env.DATABASE_PATH) {
+    rawConfig.databasePath = process.env.DATABASE_PATH;
+  }
+  const config = SparkcoderConfigSchema.parse(rawConfig);
+  const resolvedWorkingDirectory = config.workingDirectory ? resolve(configDir, config.workingDirectory) : cwd;
+  const resolvedSkillsDirectories = [
+    resolve(configDir, config.skills?.directory || "./skills"),
+    // Built-in skills
+    resolve(dirname(import.meta.url.replace("file://", "")), "../skills/default"),
+    ...(config.skills?.additionalDirectories || []).map(
+      (dir) => resolve(configDir, dir)
+    )
+  ].filter((dir) => {
+    try {
+      return existsSync(dir);
+    } catch {
+      return false;
+    }
+  });
+  const resolvedDatabasePath = resolve(configDir, config.databasePath || "./sparkecoder.db");
+  const resolved = {
+    ...config,
+    server: {
+      port: config.server.port,
+      host: config.server.host ?? "127.0.0.1"
+    },
+    resolvedWorkingDirectory,
+    resolvedSkillsDirectories,
+    resolvedDatabasePath
+  };
+  cachedConfig = resolved;
+  return resolved;
+}
+function getConfig() {
+  if (!cachedConfig) {
+    throw new Error("Config not loaded. Call loadConfig first.");
+  }
+  return cachedConfig;
+}
+function requiresApproval(toolName, sessionConfig) {
+  const config = getConfig();
+  if (sessionConfig?.toolApprovals?.[toolName] !== void 0) {
+    return sessionConfig.toolApprovals[toolName];
+  }
+  const globalApprovals = config.toolApprovals;
+  if (globalApprovals[toolName] !== void 0) {
+    return globalApprovals[toolName];
+  }
+  if (toolName === "bash") {
+    return true;
+  }
+  return false;
+}
+
+// src/tools/bash.ts
+import { tool } from "ai";
+import { z as z2 } from "zod";
+import { exec } from "child_process";
+import { promisify } from "util";
+
+// src/utils/truncate.ts
+var MAX_OUTPUT_CHARS = 1e4;
+function truncateOutput(output, maxChars = MAX_OUTPUT_CHARS) {
+  if (output.length <= maxChars) {
+    return output;
+  }
+  const halfMax = Math.floor(maxChars / 2);
+  const truncatedChars = output.length - maxChars;
+  return output.slice(0, halfMax) + `
+
+... [TRUNCATED: ${truncatedChars.toLocaleString()} characters omitted] ...
+
+` + output.slice(-halfMax);
+}
+function calculateContextSize(messages2) {
+  return messages2.reduce((total, msg) => {
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    return total + content.length;
+  }, 0);
+}
+
+// src/tools/bash.ts
+var execAsync = promisify(exec);
+var COMMAND_TIMEOUT = 6e4;
+var MAX_OUTPUT_CHARS2 = 1e4;
+var BLOCKED_COMMANDS = [
+  "rm -rf /",
+  "rm -rf ~",
+  "mkfs",
+  "dd if=/dev/zero",
+  ":(){:|:&};:",
+  "chmod -R 777 /"
+];
+function isBlockedCommand(command) {
+  const normalizedCommand = command.toLowerCase().trim();
+  return BLOCKED_COMMANDS.some(
+    (blocked) => normalizedCommand.includes(blocked.toLowerCase())
+  );
+}
+var bashInputSchema = z2.object({
+  command: z2.string().describe("The bash command to execute. Can be a single command or a pipeline.")
+});
+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.`,
+    inputSchema: bashInputSchema,
+    execute: async ({ command }) => {
+      if (isBlockedCommand(command)) {
+        return {
+          success: false,
+          error: "This command is blocked for safety reasons.",
+          stdout: "",
+          stderr: "",
+          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);
+        }
+        return {
+          success: true,
+          stdout: truncatedStdout,
+          stderr: truncatedStderr,
+          exitCode: 0
+        };
+      } 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) {
+          return {
+            success: false,
+            error: `Command timed out after ${COMMAND_TIMEOUT / 1e3} seconds`,
+            stdout,
+            stderr,
+            exitCode: 124
+            // Standard timeout exit code
+          };
+        }
+        return {
+          success: false,
+          error: error.message,
+          stdout,
+          stderr,
+          exitCode: error.code ?? 1
+        };
+      }
+    }
+  });
+}
+
+// src/tools/read-file.ts
+import { tool as tool2 } from "ai";
+import { z as z3 } from "zod";
+import { readFile, stat } from "fs/promises";
+import { resolve as resolve2, relative, isAbsolute } from "path";
+import { existsSync as existsSync2 } from "fs";
+var MAX_FILE_SIZE = 5 * 1024 * 1024;
+var MAX_OUTPUT_CHARS3 = 5e4;
+var readFileInputSchema = z3.object({
+  path: z3.string().describe("The path to the file to read. Can be relative to working directory or absolute."),
+  startLine: z3.number().optional().describe("Optional: Start reading from this line number (1-indexed)"),
+  endLine: z3.number().optional().describe("Optional: Stop reading at this line number (1-indexed, inclusive)")
+});
+function createReadFileTool(options) {
+  return tool2({
+    description: `Read the contents of a file. Provide a path relative to the working directory (${options.workingDirectory}) or an absolute path.
+Large files will be automatically truncated. Binary files are not supported.
+Use this to understand existing code, check file contents, or gather context.`,
+    inputSchema: readFileInputSchema,
+    execute: async ({ path, startLine, endLine }) => {
+      try {
+        const absolutePath = isAbsolute(path) ? path : resolve2(options.workingDirectory, path);
+        const relativePath = relative(options.workingDirectory, absolutePath);
+        if (relativePath.startsWith("..") && !isAbsolute(path)) {
+          return {
+            success: false,
+            error: "Path escapes the working directory. Use an absolute path if intentional.",
+            content: null
+          };
+        }
+        if (!existsSync2(absolutePath)) {
+          return {
+            success: false,
+            error: `File not found: ${path}`,
+            content: null
+          };
+        }
+        const stats = await stat(absolutePath);
+        if (stats.size > MAX_FILE_SIZE) {
+          return {
+            success: false,
+            error: `File is too large (${(stats.size / 1024 / 1024).toFixed(2)}MB). Maximum size is ${MAX_FILE_SIZE / 1024 / 1024}MB.`,
+            content: null
+          };
+        }
+        if (stats.isDirectory()) {
+          return {
+            success: false,
+            error: 'Path is a directory, not a file. Use bash with "ls" to list directory contents.',
+            content: null
+          };
+        }
+        let content = await readFile(absolutePath, "utf-8");
+        if (startLine !== void 0 || endLine !== void 0) {
+          const lines = content.split("\n");
+          const start = (startLine ?? 1) - 1;
+          const end = endLine ?? lines.length;
+          if (start < 0 || start >= lines.length) {
+            return {
+              success: false,
+              error: `Start line ${startLine} is out of range. File has ${lines.length} lines.`,
+              content: null
+            };
+          }
+          content = lines.slice(start, end).join("\n");
+          const lineNumbers = lines.slice(start, end).map((line, idx) => `${(start + idx + 1).toString().padStart(4)}: ${line}`).join("\n");
+          content = lineNumbers;
+        }
+        const truncatedContent = truncateOutput(content, MAX_OUTPUT_CHARS3);
+        const wasTruncated = truncatedContent.length < content.length;
+        return {
+          success: true,
+          path: absolutePath,
+          relativePath: relative(options.workingDirectory, absolutePath),
+          content: truncatedContent,
+          lineCount: content.split("\n").length,
+          wasTruncated,
+          sizeBytes: stats.size
+        };
+      } catch (error) {
+        if (error.code === "ERR_INVALID_ARG_VALUE" || error.message.includes("encoding")) {
+          return {
+            success: false,
+            error: "File appears to be binary and cannot be read as text.",
+            content: null
+          };
+        }
+        return {
+          success: false,
+          error: error.message,
+          content: null
+        };
+      }
+    }
+  });
+}
+
+// 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";
+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'),
+  content: z4.string().optional().describe('For "full" mode: The complete content to write to the file'),
+  old_string: z4.string().optional().describe('For "str_replace" mode: The exact string to find and replace'),
+  new_string: z4.string().optional().describe('For "str_replace" mode: The string to replace old_string with')
+});
+function createWriteFileTool(options) {
+  return tool3({
+    description: `Write content to a file. Supports two modes:
+1. "full" - Write the entire file content (creates new file or replaces existing)
+2. "str_replace" - Replace a specific string in an existing file (for precise edits)
+
+For str_replace mode:
+- Provide the exact string to find (old_string) and its replacement (new_string)
+- The old_string must match EXACTLY (including whitespace and indentation)
+- Only the first occurrence is replaced
+- Use this for surgical edits to existing code
+
+For full mode:
+- Provide the complete file content
+- Creates parent directories if they don't exist
+- Use this for new files or complete rewrites
+
+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);
+        if (relativePath.startsWith("..") && !isAbsolute2(path)) {
+          return {
+            success: false,
+            error: "Path escapes the working directory. Use an absolute path if intentional."
+          };
+        }
+        if (mode === "full") {
+          if (content === void 0) {
+            return {
+              success: false,
+              error: 'Content is required for "full" mode'
+            };
+          }
+          const dir = dirname2(absolutePath);
+          if (!existsSync3(dir)) {
+            await mkdir(dir, { recursive: true });
+          }
+          const existed = existsSync3(absolutePath);
+          await writeFile(absolutePath, content, "utf-8");
+          return {
+            success: true,
+            path: absolutePath,
+            relativePath: relative2(options.workingDirectory, absolutePath),
+            mode: "full",
+            action: existed ? "replaced" : "created",
+            bytesWritten: Buffer.byteLength(content, "utf-8"),
+            lineCount: content.split("\n").length
+          };
+        } else if (mode === "str_replace") {
+          if (old_string === void 0 || new_string === void 0) {
+            return {
+              success: false,
+              error: 'Both old_string and new_string are required for "str_replace" mode'
+            };
+          }
+          if (!existsSync3(absolutePath)) {
+            return {
+              success: false,
+              error: `File not found: ${path}. Use "full" mode to create new files.`
+            };
+          }
+          const currentContent = await readFile2(absolutePath, "utf-8");
+          if (!currentContent.includes(old_string)) {
+            const lines = currentContent.split("\n");
+            const preview = lines.slice(0, 20).join("\n");
+            return {
+              success: false,
+              error: "old_string not found in file. The string must match EXACTLY including whitespace.",
+              hint: "Check for differences in indentation, line endings, or invisible characters.",
+              filePreview: lines.length > 20 ? `${preview}
+... (${lines.length - 20} more lines)` : preview
+            };
+          }
+          const occurrences = currentContent.split(old_string).length - 1;
+          if (occurrences > 1) {
+            return {
+              success: false,
+              error: `Found ${occurrences} occurrences of old_string. Please provide more context to make it unique.`,
+              hint: "Include surrounding lines or more specific content in old_string."
+            };
+          }
+          const newContent = currentContent.replace(old_string, new_string);
+          await writeFile(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),
+            mode: "str_replace",
+            linesRemoved: oldLines,
+            linesAdded: newLines,
+            lineDelta: newLines - oldLines
+          };
+        }
+        return {
+          success: false,
+          error: `Invalid mode: ${mode}`
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+
+// src/tools/todo.ts
+import { tool as tool4 } from "ai";
+import { z as z5 } from "zod";
+var todoInputSchema = z5.object({
+  action: z5.enum(["add", "list", "mark", "clear"]).describe("The action to perform on the todo list"),
+  items: z5.array(
+    z5.object({
+      content: z5.string().describe("Description of the task"),
+      order: z5.number().optional().describe("Optional order/priority (lower = higher priority)")
+    })
+  ).optional().describe('For "add" action: Array of todo items to add'),
+  todoId: z5.string().optional().describe('For "mark" action: The ID of the todo item to update'),
+  status: z5.enum(["pending", "in_progress", "completed", "cancelled"]).optional().describe('For "mark" action: The new status for the todo item')
+});
+function createTodoTool(options) {
+  return tool4({
+    description: `Manage your task list for the current session. Use this to:
+- Break down complex tasks into smaller steps
+- Track progress on multi-step operations
+- Organize your work systematically
+
+Available actions:
+- "add": Add one or more new todo items to the list
+- "list": View all current todo items and their status
+- "mark": Update the status of a todo item (pending, in_progress, completed, cancelled)
+- "clear": Remove all todo items from the list
+
+Best practices:
+- Add todos before starting complex tasks
+- Mark items as "in_progress" when actively working on them
+- Update status as you complete each step`,
+    inputSchema: todoInputSchema,
+    execute: async ({ action, items, todoId, status }) => {
+      try {
+        switch (action) {
+          case "add": {
+            if (!items || items.length === 0) {
+              return {
+                success: false,
+                error: "No items provided. Include at least one todo item."
+              };
+            }
+            const created = todoQueries.createMany(options.sessionId, items);
+            return {
+              success: true,
+              action: "add",
+              itemsAdded: created.length,
+              items: created.map(formatTodoItem)
+            };
+          }
+          case "list": {
+            const todos = todoQueries.getBySession(options.sessionId);
+            const stats = {
+              total: todos.length,
+              pending: todos.filter((t) => t.status === "pending").length,
+              inProgress: todos.filter((t) => t.status === "in_progress").length,
+              completed: todos.filter((t) => t.status === "completed").length,
+              cancelled: todos.filter((t) => t.status === "cancelled").length
+            };
+            return {
+              success: true,
+              action: "list",
+              stats,
+              items: todos.map(formatTodoItem)
+            };
+          }
+          case "mark": {
+            if (!todoId) {
+              return {
+                success: false,
+                error: 'todoId is required for "mark" action'
+              };
+            }
+            if (!status) {
+              return {
+                success: false,
+                error: 'status is required for "mark" action'
+              };
+            }
+            const updated = todoQueries.updateStatus(todoId, status);
+            if (!updated) {
+              return {
+                success: false,
+                error: `Todo item not found: ${todoId}`
+              };
+            }
+            return {
+              success: true,
+              action: "mark",
+              item: formatTodoItem(updated)
+            };
+          }
+          case "clear": {
+            const count = todoQueries.clearSession(options.sessionId);
+            return {
+              success: true,
+              action: "clear",
+              itemsRemoved: count
+            };
+          }
+          default:
+            return {
+              success: false,
+              error: `Unknown action: ${action}`
+            };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+function formatTodoItem(item) {
+  return {
+    id: item.id,
+    content: item.content,
+    status: item.status,
+    order: item.order,
+    createdAt: item.createdAt.toISOString()
+  };
+}
+
+// src/tools/load-skill.ts
+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";
+function parseSkillFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!frontmatterMatch) {
+    return null;
+  }
+  const [, frontmatter, body] = frontmatterMatch;
+  try {
+    const lines = frontmatter.split("\n");
+    const data = {};
+    for (const line of lines) {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex > 0) {
+        const key = line.slice(0, colonIndex).trim();
+        let value = line.slice(colonIndex + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        data[key] = value;
+      }
+    }
+    const metadata = SkillMetadataSchema.parse(data);
+    return { metadata, body: body.trim() };
+  } catch {
+    return null;
+  }
+}
+function getSkillNameFromPath(filePath) {
+  return basename(filePath, extname(filePath)).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+async function loadSkillsFromDirectory(directory) {
+  if (!existsSync4(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 parsed = parseSkillFrontmatter(content);
+    if (parsed) {
+      skills.push({
+        name: parsed.metadata.name,
+        description: parsed.metadata.description,
+        filePath
+      });
+    } else {
+      const name = getSkillNameFromPath(filePath);
+      const firstParagraph = content.split("\n\n")[0]?.slice(0, 200) || "No description";
+      skills.push({
+        name,
+        description: firstParagraph.replace(/^#\s*/, "").trim(),
+        filePath
+      });
+    }
+  }
+  return skills;
+}
+async function loadAllSkills(directories) {
+  const allSkills = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  for (const dir of directories) {
+    const skills = await loadSkillsFromDirectory(dir);
+    for (const skill of skills) {
+      if (!seenNames.has(skill.name.toLowerCase())) {
+        seenNames.add(skill.name.toLowerCase());
+        allSkills.push(skill);
+      }
+    }
+  }
+  return allSkills;
+}
+async function loadSkillContent(skillName, directories) {
+  const allSkills = await loadAllSkills(directories);
+  const skill = allSkills.find(
+    (s) => s.name.toLowerCase() === skillName.toLowerCase()
+  );
+  if (!skill) {
+    return null;
+  }
+  const content = await readFile3(skill.filePath, "utf-8");
+  const parsed = parseSkillFrontmatter(content);
+  return {
+    ...skill,
+    content: parsed ? parsed.body : content
+  };
+}
+function formatSkillsForContext(skills) {
+  if (skills.length === 0) {
+    return "No skills available.";
+  }
+  const lines = ["Available skills (use load_skill tool to load into context):"];
+  for (const skill of skills) {
+    lines.push(`- ${skill.name}: ${skill.description}`);
+  }
+  return lines.join("\n");
+}
+
+// src/tools/load-skill.ts
+var loadSkillInputSchema = z6.object({
+  action: z6.enum(["list", "load"]).describe('Action to perform: "list" to see available skills, "load" to load a skill'),
+  skillName: z6.string().optional().describe('For "load" action: The name of the skill to load')
+});
+function createLoadSkillTool(options) {
+  return tool5({
+    description: `Load a skill document into the conversation context. Skills are specialized knowledge files that provide guidance on specific topics like debugging, code review, architecture patterns, etc.
+
+Available actions:
+- "list": Show all available skills with their descriptions
+- "load": Load a specific skill's full content into context
+
+Use this when you need specialized knowledge or guidance for a particular task.
+Once loaded, a skill's content will be available in the conversation context.`,
+    inputSchema: loadSkillInputSchema,
+    execute: async ({ action, skillName }) => {
+      try {
+        switch (action) {
+          case "list": {
+            const skills = await loadAllSkills(options.skillsDirectories);
+            return {
+              success: true,
+              action: "list",
+              skillCount: skills.length,
+              skills: skills.map((s) => ({
+                name: s.name,
+                description: s.description
+              })),
+              formatted: formatSkillsForContext(skills)
+            };
+          }
+          case "load": {
+            if (!skillName) {
+              return {
+                success: false,
+                error: 'skillName is required for "load" action'
+              };
+            }
+            if (skillQueries.isLoaded(options.sessionId, skillName)) {
+              return {
+                success: false,
+                error: `Skill "${skillName}" is already loaded in this session`
+              };
+            }
+            const skill = await loadSkillContent(skillName, options.skillsDirectories);
+            if (!skill) {
+              const allSkills = await loadAllSkills(options.skillsDirectories);
+              return {
+                success: false,
+                error: `Skill "${skillName}" not found`,
+                availableSkills: allSkills.map((s) => s.name)
+              };
+            }
+            skillQueries.load(options.sessionId, skillName);
+            return {
+              success: true,
+              action: "load",
+              skillName: skill.name,
+              description: skill.description,
+              content: skill.content,
+              contentLength: skill.content.length
+            };
+          }
+          default:
+            return {
+              success: false,
+              error: `Unknown action: ${action}`
+            };
+        }
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  });
+}
+
+// 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 terminals3 = terminalQueries.getBySession(sessionId);
+    return terminals3.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 terminals3 = manager.list(sessionId);
+          return {
+            success: true,
+            terminals: terminals3.map(formatTerminal),
+            count: terminals3.length,
+            running: terminals3.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
+    }),
+    read_file: createReadFileTool({
+      workingDirectory: options.workingDirectory
+    }),
+    write_file: createWriteFileTool({
+      workingDirectory: options.workingDirectory
+    }),
+    todo: createTodoTool({
+      sessionId: options.sessionId
+    }),
+    load_skill: createLoadSkillTool({
+      sessionId: options.sessionId,
+      skillsDirectories: options.skillsDirectories
+    }),
+    terminal: createTerminalTool({
+      sessionId: options.sessionId,
+      workingDirectory: options.workingDirectory
+    })
+  };
+}
+
+// src/agent/context.ts
+import { generateText } from "ai";
+import { gateway } from "@ai-sdk/gateway";
+
+// src/agent/prompts.ts
+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.
+
+## Working Directory
+You are working in: ${workingDirectory}
+
+## Core Capabilities
+You have access to powerful tools for:
+- **bash**: Execute shell commands, run scripts, install packages, use git
+- **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
+
+## Guidelines
+
+### Code Quality
+- Write clean, maintainable, well-documented code
+- Follow existing code style and conventions in the project
+- Use meaningful variable and function names
+- Add comments for complex logic
+
+### Problem Solving
+- Before making changes, understand the existing code structure
+- Break complex tasks into smaller, manageable steps using the todo tool
+- Test changes when possible using the bash tool
+- Handle errors gracefully and provide helpful error messages
+
+### File Operations
+- Use \`read_file\` to understand code before modifying
+- Use \`write_file\` with mode "str_replace" for targeted edits to existing files
+- Use \`write_file\` with mode "full" only for new files or complete rewrites
+- Always verify changes by reading files after modifications
+
+### Communication
+- Explain your reasoning and approach
+- Be concise but thorough
+- Ask clarifying questions when requirements are ambiguous
+- Report progress on multi-step tasks
+
+## Skills
+${skillsContext}
+
+## Current Task List
+${todosContext}
+
+${customInstructions ? `## Custom Instructions
+${customInstructions}` : ""}
+
+Remember: You are a helpful, capable coding assistant. Take initiative, be thorough, and deliver high-quality results.`;
+  return systemPrompt;
+}
+function formatTodosForContext(todos) {
+  if (todos.length === 0) {
+    return "No active tasks. Use the todo tool to create a plan for complex operations.";
+  }
+  const statusEmoji = {
+    pending: "\u2B1C",
+    in_progress: "\u{1F504}",
+    completed: "\u2705",
+    cancelled: "\u274C"
+  };
+  const lines = ["Current tasks:"];
+  for (const todo of todos) {
+    const emoji = statusEmoji[todo.status] || "\u2022";
+    lines.push(`${emoji} [${todo.id}] ${todo.content}`);
+  }
+  return lines.join("\n");
+}
+function createSummaryPrompt(conversationHistory) {
+  return `Please provide a concise summary of the following conversation history. Focus on:
+1. The main task or goal being worked on
+2. Key decisions made
+3. Important code changes or file operations performed
+4. Current state and any pending actions
+
+Keep the summary under 2000 characters while preserving essential context for continuing the work.
+
+Conversation to summarize:
+${conversationHistory}
+
+Summary:`;
+}
+
+// src/agent/context.ts
+var ContextManager = class {
+  sessionId;
+  maxContextChars;
+  keepRecentMessages;
+  autoSummarize;
+  summary = null;
+  constructor(options) {
+    this.sessionId = options.sessionId;
+    this.maxContextChars = options.maxContextChars;
+    this.keepRecentMessages = options.keepRecentMessages;
+    this.autoSummarize = options.autoSummarize;
+  }
+  /**
+   * Get messages for the current context
+   * Returns ModelMessage[] that can be passed directly to streamText/generateText
+   */
+  async getMessages() {
+    let modelMessages = messageQueries.getModelMessages(this.sessionId);
+    const contextSize = calculateContextSize(modelMessages);
+    if (this.autoSummarize && contextSize > this.maxContextChars) {
+      modelMessages = await this.summarizeContext(modelMessages);
+    }
+    if (this.summary) {
+      modelMessages = [
+        {
+          role: "system",
+          content: `[Previous conversation summary]
+${this.summary}`
+        },
+        ...modelMessages
+      ];
+    }
+    return modelMessages;
+  }
+  /**
+   * Summarize older messages to reduce context size
+   */
+  async summarizeContext(messages2) {
+    if (messages2.length <= this.keepRecentMessages) {
+      return messages2;
+    }
+    const splitIndex = messages2.length - this.keepRecentMessages;
+    const oldMessages = messages2.slice(0, splitIndex);
+    const recentMessages = messages2.slice(splitIndex);
+    const historyText = oldMessages.map((msg) => {
+      const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+      return `[${msg.role}]: ${content}`;
+    }).join("\n\n");
+    try {
+      const config = getConfig();
+      const summaryPrompt = createSummaryPrompt(historyText);
+      const result = await generateText({
+        model: gateway(config.defaultModel),
+        prompt: summaryPrompt
+      });
+      this.summary = result.text;
+      console.log(`[Context] Summarized ${oldMessages.length} messages into ${this.summary.length} chars`);
+      return recentMessages;
+    } catch (error) {
+      console.error("[Context] Failed to summarize:", error);
+      return recentMessages;
+    }
+  }
+  /**
+   * Add a user message to the context
+   */
+  addUserMessage(text2) {
+    const userMessage = {
+      role: "user",
+      content: text2
+    };
+    messageQueries.create(this.sessionId, userMessage);
+  }
+  /**
+   * Add response messages from AI SDK directly
+   * This is the preferred method - use result.response.messages from streamText/generateText
+   */
+  addResponseMessages(messages2) {
+    messageQueries.addMany(this.sessionId, messages2);
+  }
+  /**
+   * Get current context statistics
+   */
+  getStats() {
+    const messages2 = messageQueries.getModelMessages(this.sessionId);
+    return {
+      messageCount: messages2.length,
+      contextChars: calculateContextSize(messages2),
+      hasSummary: this.summary !== null
+    };
+  }
+  /**
+   * Clear all messages in the context
+   */
+  clear() {
+    messageQueries.deleteBySession(this.sessionId);
+    this.summary = null;
+  }
+};
+
+// src/agent/index.ts
+var approvalResolvers = /* @__PURE__ */ new Map();
+var Agent = class _Agent {
+  session;
+  context;
+  tools;
+  pendingApprovals = /* @__PURE__ */ new Map();
+  constructor(session, context, tools) {
+    this.session = session;
+    this.context = context;
+    this.tools = tools;
+  }
+  /**
+   * Create or resume an agent session
+   */
+  static async create(options = {}) {
+    const config = getConfig();
+    let session;
+    if (options.sessionId) {
+      const existing = sessionQueries.getById(options.sessionId);
+      if (!existing) {
+        throw new Error(`Session not found: ${options.sessionId}`);
+      }
+      session = existing;
+    } else {
+      session = sessionQueries.create({
+        name: options.name,
+        workingDirectory: options.workingDirectory || config.resolvedWorkingDirectory,
+        model: options.model || config.defaultModel,
+        config: options.sessionConfig
+      });
+    }
+    const context = new ContextManager({
+      sessionId: session.id,
+      maxContextChars: config.context?.maxChars || 2e5,
+      keepRecentMessages: config.context?.keepRecentMessages || 10,
+      autoSummarize: config.context?.autoSummarize ?? true
+    });
+    const tools = createTools({
+      sessionId: session.id,
+      workingDirectory: session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories
+    });
+    return new _Agent(session, context, tools);
+  }
+  /**
+   * Get the session ID
+   */
+  get sessionId() {
+    return this.session.id;
+  }
+  /**
+   * Get session details
+   */
+  getSession() {
+    return this.session;
+  }
+  /**
+   * Run the agent with a prompt (streaming)
+   */
+  async stream(options) {
+    const config = getConfig();
+    this.context.addUserMessage(options.prompt);
+    sessionQueries.updateStatus(this.session.id, "active");
+    const systemPrompt = await buildSystemPrompt({
+      workingDirectory: this.session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories,
+      sessionId: this.session.id
+    });
+    const messages2 = await this.context.getMessages();
+    const wrappedTools = this.wrapToolsWithApproval(options);
+    const stream = streamText({
+      model: gateway2(this.session.model),
+      system: systemPrompt,
+      messages: messages2,
+      tools: wrappedTools,
+      stopWhen: stepCountIs(20),
+      onStepFinish: async (step) => {
+        options.onStepFinish?.(step);
+      }
+    });
+    const saveResponseMessages = async () => {
+      const result = await stream;
+      const response = await result.response;
+      const responseMessages = response.messages;
+      this.context.addResponseMessages(responseMessages);
+    };
+    return {
+      sessionId: this.session.id,
+      stream,
+      waitForApprovals: () => this.waitForApprovals(),
+      saveResponseMessages
+    };
+  }
+  /**
+   * Run the agent with a prompt (non-streaming)
+   */
+  async run(options) {
+    const config = getConfig();
+    this.context.addUserMessage(options.prompt);
+    const systemPrompt = await buildSystemPrompt({
+      workingDirectory: this.session.workingDirectory,
+      skillsDirectories: config.resolvedSkillsDirectories,
+      sessionId: this.session.id
+    });
+    const messages2 = await this.context.getMessages();
+    const wrappedTools = this.wrapToolsWithApproval(options);
+    const result = await generateText2({
+      model: gateway2(this.session.model),
+      system: systemPrompt,
+      messages: messages2,
+      tools: wrappedTools,
+      stopWhen: stepCountIs(20)
+    });
+    const responseMessages = result.response.messages;
+    this.context.addResponseMessages(responseMessages);
+    return {
+      text: result.text,
+      steps: result.steps
+    };
+  }
+  /**
+   * Wrap tools to add approval checking
+   */
+  wrapToolsWithApproval(options) {
+    const sessionConfig = this.session.config;
+    const wrappedTools = {};
+    for (const [name, originalTool] of Object.entries(this.tools)) {
+      const needsApproval = requiresApproval(name, sessionConfig ?? void 0);
+      if (!needsApproval) {
+        wrappedTools[name] = originalTool;
+        continue;
+      }
+      wrappedTools[name] = tool7({
+        description: originalTool.description || "",
+        inputSchema: originalTool.inputSchema || z8.object({}),
+        execute: async (input, toolOptions) => {
+          const toolCallId = toolOptions.toolCallId || nanoid2();
+          const execution = toolExecutionQueries.create({
+            sessionId: this.session.id,
+            toolName: name,
+            toolCallId,
+            input,
+            requiresApproval: true,
+            status: "pending"
+          });
+          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 resolverData = approvalResolvers.get(toolCallId);
+          approvalResolvers.delete(toolCallId);
+          this.pendingApprovals.delete(toolCallId);
+          if (!approved) {
+            const reason = resolverData?.reason || "User rejected the tool execution";
+            toolExecutionQueries.reject(execution.id);
+            sessionQueries.updateStatus(this.session.id, "active");
+            return {
+              status: "rejected",
+              toolCallId,
+              rejected: true,
+              reason,
+              message: `Tool "${name}" was rejected by the user. Reason: ${reason}`
+            };
+          }
+          toolExecutionQueries.approve(execution.id);
+          sessionQueries.updateStatus(this.session.id, "active");
+          try {
+            const result = await originalTool.execute(input, toolOptions);
+            toolExecutionQueries.complete(execution.id, result);
+            return result;
+          } catch (error) {
+            toolExecutionQueries.complete(execution.id, null, error.message);
+            throw error;
+          }
+        }
+      });
+    }
+    return wrappedTools;
+  }
+  /**
+   * Wait for all pending approvals
+   */
+  async waitForApprovals() {
+    return Array.from(this.pendingApprovals.values());
+  }
+  /**
+   * Approve a pending tool execution
+   */
+  async approve(toolCallId) {
+    const resolver = approvalResolvers.get(toolCallId);
+    if (resolver) {
+      resolver.resolve(true);
+      return { approved: true };
+    }
+    const pendingFromDb = toolExecutionQueries.getPendingApprovals(this.session.id);
+    const execution = pendingFromDb.find((e) => e.toolCallId === toolCallId);
+    if (!execution) {
+      throw new Error(`No pending approval for tool call: ${toolCallId}`);
+    }
+    toolExecutionQueries.approve(execution.id);
+    return { approved: true };
+  }
+  /**
+   * Reject a pending tool execution
+   */
+  reject(toolCallId, reason) {
+    const resolver = approvalResolvers.get(toolCallId);
+    if (resolver) {
+      resolver.reason = reason;
+      resolver.resolve(false);
+      return { rejected: true };
+    }
+    const pendingFromDb = toolExecutionQueries.getPendingApprovals(this.session.id);
+    const execution = pendingFromDb.find((e) => e.toolCallId === toolCallId);
+    if (!execution) {
+      throw new Error(`No pending approval for tool call: ${toolCallId}`);
+    }
+    toolExecutionQueries.reject(execution.id);
+    return { rejected: true };
+  }
+  /**
+   * Get pending approvals
+   */
+  getPendingApprovals() {
+    return toolExecutionQueries.getPendingApprovals(this.session.id);
+  }
+  /**
+   * Get context statistics
+   */
+  getContextStats() {
+    return this.context.getStats();
+  }
+  /**
+   * Clear conversation context (start fresh)
+   */
+  clearContext() {
+    this.context.clear();
+  }
+};
+
+// src/server/routes/sessions.ts
+var sessions2 = new Hono();
+var createSessionSchema = z9.object({
+  name: z9.string().optional(),
+  workingDirectory: z9.string().optional(),
+  model: z9.string().optional(),
+  toolApprovals: z9.record(z9.string(), z9.boolean()).optional()
+});
+var paginationQuerySchema = z9.object({
+  limit: z9.string().optional(),
+  offset: z9.string().optional()
+});
+var messagesQuerySchema = z9.object({
+  limit: z9.string().optional()
+});
+sessions2.get(
+  "/",
+  zValidator("query", paginationQuerySchema),
+  async (c) => {
+    const query = c.req.valid("query");
+    const limit = parseInt(query.limit || "50");
+    const offset = parseInt(query.offset || "0");
+    const allSessions = sessionQueries.list(limit, offset);
+    return c.json({
+      sessions: allSessions.map((s) => ({
+        id: s.id,
+        name: s.name,
+        workingDirectory: s.workingDirectory,
+        model: s.model,
+        status: s.status,
+        createdAt: s.createdAt.toISOString(),
+        updatedAt: s.updatedAt.toISOString()
+      })),
+      count: allSessions.length,
+      limit,
+      offset
+    });
+  }
+);
+sessions2.post(
+  "/",
+  zValidator("json", createSessionSchema),
+  async (c) => {
+    const body = c.req.valid("json");
+    const config = getConfig();
+    const agent = await Agent.create({
+      name: body.name,
+      workingDirectory: body.workingDirectory || config.resolvedWorkingDirectory,
+      model: body.model || config.defaultModel,
+      sessionConfig: body.toolApprovals ? { toolApprovals: body.toolApprovals } : void 0
+    });
+    const session = agent.getSession();
+    return c.json({
+      id: session.id,
+      name: session.name,
+      workingDirectory: session.workingDirectory,
+      model: session.model,
+      status: session.status,
+      createdAt: session.createdAt.toISOString()
+    }, 201);
+  }
+);
+sessions2.get("/:id", async (c) => {
+  const id = c.req.param("id");
+  const session = sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const contextStats = await (async () => {
+    const agent = await Agent.create({ sessionId: id });
+    return agent.getContextStats();
+  })();
+  const todos = todoQueries.getBySession(id);
+  const pendingApprovals = toolExecutionQueries.getPendingApprovals(id);
+  return c.json({
+    id: session.id,
+    name: session.name,
+    workingDirectory: session.workingDirectory,
+    model: session.model,
+    status: session.status,
+    config: session.config,
+    createdAt: session.createdAt.toISOString(),
+    updatedAt: session.updatedAt.toISOString(),
+    context: contextStats,
+    todos: todos.map((t) => ({
+      id: t.id,
+      content: t.content,
+      status: t.status,
+      order: t.order
+    })),
+    pendingApprovals: pendingApprovals.map((p) => ({
+      id: p.id,
+      toolCallId: p.toolCallId,
+      toolName: p.toolName,
+      input: p.input
+    }))
+  });
+});
+sessions2.get(
+  "/:id/messages",
+  zValidator("query", messagesQuerySchema),
+  async (c) => {
+    const id = c.req.param("id");
+    const query = c.req.valid("query");
+    const limit = parseInt(query.limit || "100");
+    const session = sessionQueries.getById(id);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    const messages2 = messageQueries.getRecentBySession(id, limit);
+    return c.json({
+      sessionId: id,
+      messages: messages2.map((m) => ({
+        id: m.id,
+        ...m.modelMessage,
+        // Spread the AI SDK ModelMessage (role, content)
+        createdAt: m.createdAt.toISOString()
+      })),
+      count: messages2.length
+    });
+  }
+);
+sessions2.get("/:id/tools", async (c) => {
+  const id = c.req.param("id");
+  const session = sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const executions = toolExecutionQueries.getBySession(id);
+  return c.json({
+    sessionId: id,
+    executions: executions.map((e) => ({
+      id: e.id,
+      toolCallId: e.toolCallId,
+      toolName: e.toolName,
+      input: e.input,
+      output: e.output,
+      status: e.status,
+      requiresApproval: e.requiresApproval,
+      error: e.error,
+      startedAt: e.startedAt.toISOString(),
+      completedAt: e.completedAt?.toISOString()
+    })),
+    count: executions.length
+  });
+});
+sessions2.delete("/:id", async (c) => {
+  const id = c.req.param("id");
+  try {
+    const manager = getTerminalManager();
+    manager.killAll(id);
+  } catch (e) {
+  }
+  const deleted = sessionQueries.delete(id);
+  if (!deleted) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  return c.json({ success: true, id });
+});
+sessions2.post("/:id/clear", async (c) => {
+  const id = c.req.param("id");
+  const session = sessionQueries.getById(id);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const agent = await Agent.create({ sessionId: id });
+  agent.clearContext();
+  return c.json({ success: true, sessionId: id });
+});
+
+// src/server/routes/agents.ts
+import { Hono as Hono2 } from "hono";
+import { zValidator as zValidator2 } from "@hono/zod-validator";
+import { streamSSE } from "hono/streaming";
+import { z as z10 } from "zod";
+var agents = new Hono2();
+var runPromptSchema = z10.object({
+  prompt: z10.string().min(1)
+});
+var quickStartSchema = z10.object({
+  prompt: z10.string().min(1),
+  name: z10.string().optional(),
+  workingDirectory: z10.string().optional(),
+  model: z10.string().optional(),
+  toolApprovals: z10.record(z10.string(), z10.boolean()).optional()
+});
+var rejectSchema = z10.object({
+  reason: z10.string().optional()
+}).optional();
+agents.post(
+  "/:id/run",
+  zValidator2("json", runPromptSchema),
+  async (c) => {
+    const id = c.req.param("id");
+    const { prompt } = c.req.valid("json");
+    const session = sessionQueries.getById(id);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    c.header("Content-Type", "text/event-stream");
+    c.header("Cache-Control", "no-cache");
+    c.header("Connection", "keep-alive");
+    c.header("x-vercel-ai-ui-message-stream", "v1");
+    return streamSSE(c, async (stream) => {
+      try {
+        const agent = await Agent.create({ sessionId: id });
+        const messageId = `msg_${Date.now()}`;
+        await stream.writeSSE({
+          data: JSON.stringify({ type: "start", messageId })
+        });
+        let textId = `text_${Date.now()}`;
+        let textStarted = false;
+        const result = await agent.stream({
+          prompt,
+          onToolCall: async (toolCall) => {
+            await stream.writeSSE({
+              data: JSON.stringify({
+                type: "tool-input-start",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName
+              })
+            });
+            await stream.writeSSE({
+              data: JSON.stringify({
+                type: "tool-input-available",
+                toolCallId: toolCall.toolCallId,
+                toolName: toolCall.toolName,
+                input: toolCall.input
+              })
+            });
+          },
+          onToolResult: async (result2) => {
+            await stream.writeSSE({
+              data: JSON.stringify({
+                type: "tool-output-available",
+                toolCallId: result2.toolCallId,
+                output: result2.output
+              })
+            });
+          },
+          onApprovalRequired: async (execution) => {
+            await stream.writeSSE({
+              data: JSON.stringify({
+                type: "data-approval-required",
+                data: {
+                  id: execution.id,
+                  toolCallId: execution.toolCallId,
+                  toolName: execution.toolName,
+                  input: execution.input
+                }
+              })
+            });
+          },
+          onStepFinish: async () => {
+            await stream.writeSSE({
+              data: JSON.stringify({ type: "finish-step" })
+            });
+            if (textStarted) {
+              await stream.writeSSE({
+                data: JSON.stringify({ type: "text-end", id: textId })
+              });
+              textStarted = false;
+              textId = `text_${Date.now()}`;
+            }
+          }
+        });
+        for await (const part of result.stream.fullStream) {
+          if (part.type === "text-delta") {
+            if (!textStarted) {
+              await stream.writeSSE({
+                data: JSON.stringify({ type: "text-start", id: textId })
+              });
+              textStarted = true;
+            }
+            await stream.writeSSE({
+              data: JSON.stringify({ type: "text-delta", id: textId, delta: part.text })
+            });
+          } else if (part.type === "tool-call") {
+            await stream.writeSSE({
+              data: JSON.stringify({
+                type: "tool-input-available",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: part.input
+              })
+            });
+          } else if (part.type === "tool-result") {
+            await stream.writeSSE({
+              data: JSON.stringify({
+                type: "tool-output-available",
+                toolCallId: part.toolCallId,
+                output: part.output
+              })
+            });
+          } else if (part.type === "error") {
+            console.error("Stream error:", part.error);
+            await stream.writeSSE({
+              data: JSON.stringify({ type: "error", errorText: String(part.error) })
+            });
+          }
+        }
+        if (textStarted) {
+          await stream.writeSSE({
+            data: JSON.stringify({ type: "text-end", id: textId })
+          });
+        }
+        await result.saveResponseMessages();
+        await stream.writeSSE({
+          data: JSON.stringify({ type: "finish" })
+        });
+        await stream.writeSSE({ data: "[DONE]" });
+      } catch (error) {
+        await stream.writeSSE({
+          data: JSON.stringify({
+            type: "error",
+            errorText: error.message
+          })
+        });
+        await stream.writeSSE({ data: "[DONE]" });
+      }
+    });
+  }
+);
+agents.post(
+  "/:id/generate",
+  zValidator2("json", runPromptSchema),
+  async (c) => {
+    const id = c.req.param("id");
+    const { prompt } = c.req.valid("json");
+    const session = sessionQueries.getById(id);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    try {
+      const agent = await Agent.create({ sessionId: id });
+      const result = await agent.run({ prompt });
+      return c.json({
+        sessionId: id,
+        text: result.text,
+        stepCount: result.steps.length
+      });
+    } catch (error) {
+      return c.json({ error: error.message }, 500);
+    }
+  }
+);
+agents.post("/:id/approve/:toolCallId", async (c) => {
+  const sessionId = c.req.param("id");
+  const toolCallId = c.req.param("toolCallId");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  try {
+    const agent = await Agent.create({ sessionId });
+    const result = await agent.approve(toolCallId);
+    return c.json({
+      success: true,
+      toolCallId,
+      result
+    });
+  } catch (error) {
+    return c.json({ error: error.message }, 400);
+  }
+});
+agents.post(
+  "/:id/reject/:toolCallId",
+  zValidator2("json", rejectSchema),
+  async (c) => {
+    const sessionId = c.req.param("id");
+    const toolCallId = c.req.param("toolCallId");
+    const body = c.req.valid("json");
+    const session = sessionQueries.getById(sessionId);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    try {
+      const agent = await Agent.create({ sessionId });
+      agent.reject(toolCallId, body?.reason);
+      return c.json({
+        success: true,
+        toolCallId,
+        rejected: true
+      });
+    } catch (error) {
+      return c.json({ error: error.message }, 400);
+    }
+  }
+);
+agents.get("/:id/approvals", async (c) => {
+  const sessionId = c.req.param("id");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const pendingApprovals = toolExecutionQueries.getPendingApprovals(sessionId);
+  return c.json({
+    sessionId,
+    pendingApprovals: pendingApprovals.map((p) => ({
+      id: p.id,
+      toolCallId: p.toolCallId,
+      toolName: p.toolName,
+      input: p.input,
+      startedAt: p.startedAt.toISOString()
+    })),
+    count: pendingApprovals.length
+  });
+});
+agents.post(
+  "/quick",
+  zValidator2("json", quickStartSchema),
+  async (c) => {
+    const body = c.req.valid("json");
+    const config = getConfig();
+    const agent = await Agent.create({
+      name: body.name,
+      workingDirectory: body.workingDirectory || config.resolvedWorkingDirectory,
+      model: body.model || config.defaultModel,
+      sessionConfig: body.toolApprovals ? { toolApprovals: body.toolApprovals } : void 0
+    });
+    const session = agent.getSession();
+    c.header("Content-Type", "text/event-stream");
+    c.header("Cache-Control", "no-cache");
+    c.header("Connection", "keep-alive");
+    c.header("x-vercel-ai-ui-message-stream", "v1");
+    return streamSSE(c, async (stream) => {
+      try {
+        await stream.writeSSE({
+          data: JSON.stringify({
+            type: "data-session",
+            data: {
+              id: session.id,
+              name: session.name,
+              workingDirectory: session.workingDirectory,
+              model: session.model
+            }
+          })
+        });
+        const messageId = `msg_${Date.now()}`;
+        await stream.writeSSE({
+          data: JSON.stringify({ type: "start", messageId })
+        });
+        let textId = `text_${Date.now()}`;
+        let textStarted = false;
+        const result = await agent.stream({
+          prompt: body.prompt,
+          onStepFinish: async () => {
+            await stream.writeSSE({
+              data: JSON.stringify({ type: "finish-step" })
+            });
+            if (textStarted) {
+              await stream.writeSSE({
+                data: JSON.stringify({ type: "text-end", id: textId })
+              });
+              textStarted = false;
+              textId = `text_${Date.now()}`;
+            }
+          }
+        });
+        for await (const part of result.stream.fullStream) {
+          if (part.type === "text-delta") {
+            if (!textStarted) {
+              await stream.writeSSE({
+                data: JSON.stringify({ type: "text-start", id: textId })
+              });
+              textStarted = true;
+            }
+            await stream.writeSSE({
+              data: JSON.stringify({ type: "text-delta", id: textId, delta: part.text })
+            });
+          } else if (part.type === "error") {
+            console.error("Stream error:", part.error);
+            await stream.writeSSE({
+              data: JSON.stringify({ type: "error", errorText: String(part.error) })
+            });
+          }
+        }
+        if (textStarted) {
+          await stream.writeSSE({
+            data: JSON.stringify({ type: "text-end", id: textId })
+          });
+        }
+        await result.saveResponseMessages();
+        await stream.writeSSE({
+          data: JSON.stringify({ type: "finish" })
+        });
+        await stream.writeSSE({ data: "[DONE]" });
+      } catch (error) {
+        console.error("Agent error:", error);
+        await stream.writeSSE({
+          data: JSON.stringify({ type: "error", errorText: error.message })
+        });
+        await stream.writeSSE({ data: "[DONE]" });
+      }
+    });
+  }
+);
+
+// src/server/routes/health.ts
+import { Hono as Hono3 } from "hono";
+var health = new Hono3();
+health.get("/", async (c) => {
+  const config = getConfig();
+  return c.json({
+    status: "ok",
+    version: "0.1.0",
+    uptime: process.uptime(),
+    config: {
+      workingDirectory: config.resolvedWorkingDirectory,
+      defaultModel: config.defaultModel,
+      port: config.server.port
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+});
+health.get("/ready", async (c) => {
+  try {
+    getConfig();
+    return c.json({
+      status: "ready",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch (error) {
+    return c.json(
+      {
+        status: "not_ready",
+        error: error.message,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      503
+    );
+  }
+});
+
+// src/server/routes/terminals.ts
+import { Hono as Hono4 } from "hono";
+import { zValidator as zValidator3 } from "@hono/zod-validator";
+import { z as z11 } from "zod";
+var terminals2 = new Hono4();
+var spawnSchema = z11.object({
+  command: z11.string(),
+  cwd: z11.string().optional(),
+  name: z11.string().optional()
+});
+terminals2.post(
+  "/:sessionId/terminals",
+  zValidator3("json", spawnSchema),
+  async (c) => {
+    const sessionId = c.req.param("sessionId");
+    const body = c.req.valid("json");
+    const session = sessionQueries.getById(sessionId);
+    if (!session) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    const manager = getTerminalManager();
+    const terminal = manager.spawn({
+      sessionId,
+      command: body.command,
+      cwd: body.cwd || session.workingDirectory,
+      name: body.name
+    });
+    return c.json(terminal, 201);
+  }
+);
+terminals2.get("/:sessionId/terminals", async (c) => {
+  const sessionId = c.req.param("sessionId");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const manager = getTerminalManager();
+  const terminalList = manager.list(sessionId);
+  return c.json({
+    sessionId,
+    terminals: terminalList,
+    count: terminalList.length,
+    running: terminalList.filter((t) => t.status === "running").length
+  });
+});
+terminals2.get("/:sessionId/terminals/:terminalId", async (c) => {
+  const sessionId = c.req.param("sessionId");
+  const terminalId = c.req.param("terminalId");
+  const manager = getTerminalManager();
+  const terminal = manager.getStatus(terminalId);
+  if (!terminal) {
+    return c.json({ error: "Terminal not found" }, 404);
+  }
+  return c.json(terminal);
+});
+var logsQuerySchema = z11.object({
+  tail: z11.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
+});
+terminals2.get(
+  "/:sessionId/terminals/:terminalId/logs",
+  zValidator3("query", logsQuerySchema),
+  async (c) => {
+    const terminalId = c.req.param("terminalId");
+    const query = c.req.valid("query");
+    const manager = getTerminalManager();
+    const result = manager.getLogs(terminalId, query.tail);
+    if (!result) {
+      return c.json({ error: "Terminal not found" }, 404);
+    }
+    return c.json({
+      terminalId,
+      logs: result.logs,
+      lineCount: result.lineCount
+    });
+  }
+);
+var killSchema = z11.object({
+  signal: z11.enum(["SIGTERM", "SIGKILL"]).optional()
+});
+terminals2.post(
+  "/:sessionId/terminals/:terminalId/kill",
+  zValidator3("json", killSchema.optional()),
+  async (c) => {
+    const terminalId = c.req.param("terminalId");
+    const body = await c.req.json().catch(() => ({}));
+    const manager = getTerminalManager();
+    const success = manager.kill(terminalId, body.signal);
+    if (!success) {
+      return c.json({ error: "Failed to kill terminal" }, 400);
+    }
+    return c.json({ success: true, message: `Sent ${body.signal || "SIGTERM"} to terminal` });
+  }
+);
+var writeSchema = z11.object({
+  input: z11.string()
+});
+terminals2.post(
+  "/:sessionId/terminals/:terminalId/write",
+  zValidator3("json", writeSchema),
+  async (c) => {
+    const terminalId = c.req.param("terminalId");
+    const body = c.req.valid("json");
+    const manager = getTerminalManager();
+    const success = manager.write(terminalId, body.input);
+    if (!success) {
+      return c.json({ error: "Failed to write to terminal" }, 400);
+    }
+    return c.json({ success: true });
+  }
+);
+terminals2.post("/:sessionId/terminals/kill-all", async (c) => {
+  const sessionId = c.req.param("sessionId");
+  const manager = getTerminalManager();
+  const killed = manager.killAll(sessionId);
+  return c.json({ success: true, killed });
+});
+terminals2.get("/:sessionId/terminals/:terminalId/stream", async (c) => {
+  const terminalId = c.req.param("terminalId");
+  const manager = getTerminalManager();
+  const terminal = manager.getStatus(terminalId);
+  if (!terminal) {
+    return c.json({ error: "Terminal not found" }, 404);
+  }
+  c.header("Content-Type", "text/event-stream");
+  c.header("Cache-Control", "no-cache");
+  c.header("Connection", "keep-alive");
+  return new Response(
+    new ReadableStream({
+      start(controller) {
+        const encoder = new TextEncoder();
+        const initialLogs = manager.getLogs(terminalId);
+        if (initialLogs) {
+          controller.enqueue(
+            encoder.encode(`event: logs
+data: ${JSON.stringify({ logs: initialLogs.logs })}
+
+`)
+          );
+        }
+        const onStdout = ({ terminalId: tid, data }) => {
+          if (tid === terminalId) {
+            controller.enqueue(
+              encoder.encode(`event: stdout
+data: ${JSON.stringify({ data })}
+
+`)
+            );
+          }
+        };
+        const onStderr = ({ terminalId: tid, data }) => {
+          if (tid === terminalId) {
+            controller.enqueue(
+              encoder.encode(`event: stderr
+data: ${JSON.stringify({ data })}
+
+`)
+            );
+          }
+        };
+        const onExit = ({ terminalId: tid, code, signal }) => {
+          if (tid === terminalId) {
+            controller.enqueue(
+              encoder.encode(`event: exit
+data: ${JSON.stringify({ code, signal })}
+
+`)
+            );
+            cleanup();
+            controller.close();
+          }
+        };
+        const cleanup = () => {
+          manager.off("stdout", onStdout);
+          manager.off("stderr", onStderr);
+          manager.off("exit", onExit);
+        };
+        manager.on("stdout", onStdout);
+        manager.on("stderr", onStderr);
+        manager.on("exit", onExit);
+        if (terminal.status !== "running") {
+          controller.enqueue(
+            encoder.encode(`event: exit
+data: ${JSON.stringify({ code: terminal.exitCode, status: terminal.status })}
+
+`)
+          );
+          cleanup();
+          controller.close();
+        }
+      }
+    }),
+    {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive"
+      }
+    }
+  );
+});
+
+// src/server/index.ts
+var serverInstance = null;
+async function createApp() {
+  const app = new Hono5();
+  app.use("*", cors());
+  app.use("*", logger());
+  app.route("/health", health);
+  app.route("/sessions", sessions2);
+  app.route("/agents", agents);
+  app.route("/sessions", terminals2);
+  app.get("/openapi.json", async (c) => {
+    return c.json(generateOpenAPISpec());
+  });
+  app.get("/swagger", (c) => {
+    const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Sparkecoder API - Swagger UI</title>
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css">
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+  <script>
+    SwaggerUIBundle({
+      url: '/openapi.json',
+      dom_id: '#swagger-ui',
+      presets: [SwaggerUIBundle.presets.apis, SwaggerUIBundle.SwaggerUIStandalonePreset],
+      layout: "BaseLayout"
+    });
+  </script>
+</body>
+</html>`;
+    return c.html(html);
+  });
+  app.get("/", (c) => {
+    return c.json({
+      name: "Sparkecoder API",
+      version: "0.1.0",
+      description: "A powerful coding agent CLI with HTTP API",
+      docs: "/openapi.json",
+      endpoints: {
+        health: "/health",
+        sessions: "/sessions",
+        agents: "/agents",
+        terminals: "/sessions/:sessionId/terminals"
+      }
+    });
+  });
+  return app;
+}
+async function startServer(options = {}) {
+  const config = await loadConfig(options.configPath, options.workingDirectory);
+  if (options.workingDirectory) {
+    config.resolvedWorkingDirectory = options.workingDirectory;
+  }
+  if (!existsSync5(config.resolvedWorkingDirectory)) {
+    mkdirSync(config.resolvedWorkingDirectory, { recursive: true });
+    console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
+  }
+  initDatabase(config.resolvedDatabasePath);
+  const port = options.port || config.server.port;
+  const host = options.host || config.server.host || "0.0.0.0";
+  const app = await createApp();
+  console.log(`
+\u{1F680} Sparkecoder API Server`);
+  console.log(`   \u2192 Running at http://${host}:${port}`);
+  console.log(`   \u2192 Working directory: ${config.resolvedWorkingDirectory}`);
+  console.log(`   \u2192 Default model: ${config.defaultModel}`);
+  console.log(`   \u2192 OpenAPI spec: http://${host}:${port}/openapi.json
+`);
+  serverInstance = serve({
+    fetch: app.fetch,
+    port,
+    hostname: host
+  });
+  return { app, port, host };
+}
+function stopServer() {
+  try {
+    const manager = getTerminalManager();
+    manager.cleanup();
+  } catch (e) {
+  }
+  if (serverInstance) {
+    serverInstance.close();
+    serverInstance = null;
+  }
+  closeDatabase();
+}
+function generateOpenAPISpec() {
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "Sparkecoder API",
+      version: "0.1.0",
+      description: "A powerful coding agent CLI with HTTP API for development environments. Supports streaming responses following the Vercel AI SDK data stream protocol."
+    },
+    servers: [{ url: "http://localhost:3141", description: "Local development" }],
+    paths: {
+      "/": {
+        get: {
+          summary: "API Info",
+          description: "Get basic API information and available endpoints",
+          responses: {
+            200: {
+              description: "API information",
+              content: { "application/json": {} }
+            }
+          }
+        }
+      },
+      "/health": {
+        get: {
+          summary: "Health Check",
+          description: "Check API health status and configuration",
+          responses: {
+            200: {
+              description: "API is healthy",
+              content: { "application/json": {} }
+            }
+          }
+        }
+      },
+      "/health/ready": {
+        get: {
+          summary: "Readiness Check",
+          description: "Check if the API is ready to accept requests",
+          responses: {
+            200: { description: "API is ready" },
+            503: { description: "API is not ready" }
+          }
+        }
+      },
+      "/sessions": {
+        get: {
+          summary: "List Sessions",
+          description: "Get a list of all agent sessions",
+          parameters: [
+            { name: "limit", in: "query", schema: { type: "integer", default: 50 } },
+            { name: "offset", in: "query", schema: { type: "integer", default: 0 } }
+          ],
+          responses: {
+            200: { description: "List of sessions" }
+          }
+        },
+        post: {
+          summary: "Create Session",
+          description: "Create a new agent session",
+          requestBody: {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    name: { type: "string" },
+                    workingDirectory: { type: "string" },
+                    model: { type: "string" },
+                    toolApprovals: { type: "object" }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            201: { description: "Session created" }
+          }
+        }
+      },
+      "/sessions/{id}": {
+        get: {
+          summary: "Get Session",
+          description: "Get details of a specific session",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: {
+            200: { description: "Session details" },
+            404: { description: "Session not found" }
+          }
+        },
+        delete: {
+          summary: "Delete Session",
+          description: "Delete a session and all its data",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: {
+            200: { description: "Session deleted" },
+            404: { description: "Session not found" }
+          }
+        }
+      },
+      "/sessions/{id}/messages": {
+        get: {
+          summary: "Get Messages",
+          description: "Get message history for a session",
+          parameters: [
+            { name: "id", in: "path", required: true, schema: { type: "string" } },
+            { name: "limit", in: "query", schema: { type: "integer", default: 100 } }
+          ],
+          responses: {
+            200: { description: "Message history" },
+            404: { description: "Session not found" }
+          }
+        }
+      },
+      "/sessions/{id}/clear": {
+        post: {
+          summary: "Clear Context",
+          description: "Clear conversation context for a session",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: {
+            200: { description: "Context cleared" },
+            404: { description: "Session not found" }
+          }
+        }
+      },
+      "/agents/{id}/run": {
+        post: {
+          summary: "Run Agent (Streaming)",
+          description: "Run the agent with a prompt and receive streaming response. Returns SSE stream following Vercel AI SDK data stream protocol.",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          requestBody: {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: ["prompt"],
+                  properties: {
+                    prompt: { type: "string" }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            200: {
+              description: "SSE stream of agent output",
+              content: { "text/event-stream": {} }
+            },
+            404: { description: "Session not found" }
+          }
+        }
+      },
+      "/agents/{id}/generate": {
+        post: {
+          summary: "Run Agent (Non-streaming)",
+          description: "Run the agent and receive complete response",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          requestBody: {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: ["prompt"],
+                  properties: {
+                    prompt: { type: "string" }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            200: { description: "Agent response" },
+            404: { description: "Session not found" }
+          }
+        }
+      },
+      "/agents/{id}/approve/{toolCallId}": {
+        post: {
+          summary: "Approve Tool",
+          description: "Approve a pending tool execution",
+          parameters: [
+            { name: "id", in: "path", required: true, schema: { type: "string" } },
+            { name: "toolCallId", in: "path", required: true, schema: { type: "string" } }
+          ],
+          responses: {
+            200: { description: "Tool approved and executed" },
+            400: { description: "Approval failed" },
+            404: { description: "Session not found" }
+          }
+        }
+      },
+      "/agents/{id}/reject/{toolCallId}": {
+        post: {
+          summary: "Reject Tool",
+          description: "Reject a pending tool execution",
+          parameters: [
+            { name: "id", in: "path", required: true, schema: { type: "string" } },
+            { name: "toolCallId", in: "path", required: true, schema: { type: "string" } }
+          ],
+          requestBody: {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    reason: { type: "string" }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            200: { description: "Tool rejected" },
+            400: { description: "Rejection failed" },
+            404: { description: "Session not found" }
+          }
+        }
+      },
+      "/agents/{id}/approvals": {
+        get: {
+          summary: "Get Pending Approvals",
+          description: "Get all pending tool approvals for a session",
+          parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }],
+          responses: {
+            200: { description: "Pending approvals" },
+            404: { description: "Session not found" }
+          }
+        }
+      },
+      "/agents/quick": {
+        post: {
+          summary: "Quick Start",
+          description: "Create a session and run agent in one request",
+          requestBody: {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: ["prompt"],
+                  properties: {
+                    prompt: { type: "string" },
+                    name: { type: "string" },
+                    workingDirectory: { type: "string" },
+                    model: { type: "string" },
+                    toolApprovals: { type: "object" }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            200: {
+              description: "SSE stream of agent output",
+              content: { "text/event-stream": {} }
+            }
+          }
+        }
+      },
+      "/sessions/{sessionId}/terminals": {
+        get: {
+          summary: "List Terminals",
+          description: "Get all terminals for a session",
+          parameters: [{ name: "sessionId", in: "path", required: true, schema: { type: "string" } }],
+          responses: {
+            200: { description: "List of terminals" },
+            404: { description: "Session not found" }
+          }
+        },
+        post: {
+          summary: "Spawn Terminal",
+          description: "Start a new background process",
+          parameters: [{ name: "sessionId", in: "path", required: true, schema: { type: "string" } }],
+          requestBody: {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: ["command"],
+                  properties: {
+                    command: { type: "string" },
+                    cwd: { type: "string" },
+                    name: { type: "string" }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            201: { description: "Terminal spawned" },
+            404: { description: "Session not found" }
+          }
+        }
+      },
+      "/sessions/{sessionId}/terminals/{terminalId}": {
+        get: {
+          summary: "Get Terminal Status",
+          description: "Get status and details of a terminal",
+          parameters: [
+            { name: "sessionId", in: "path", required: true, schema: { type: "string" } },
+            { name: "terminalId", in: "path", required: true, schema: { type: "string" } }
+          ],
+          responses: {
+            200: { description: "Terminal status" },
+            404: { description: "Terminal not found" }
+          }
+        }
+      },
+      "/sessions/{sessionId}/terminals/{terminalId}/logs": {
+        get: {
+          summary: "Get Terminal Logs",
+          description: "Get output logs from a terminal",
+          parameters: [
+            { name: "sessionId", in: "path", required: true, schema: { type: "string" } },
+            { name: "terminalId", in: "path", required: true, schema: { type: "string" } },
+            { name: "tail", in: "query", schema: { type: "integer" } }
+          ],
+          responses: {
+            200: { description: "Terminal logs" },
+            404: { description: "Terminal not found" }
+          }
+        }
+      },
+      "/sessions/{sessionId}/terminals/{terminalId}/kill": {
+        post: {
+          summary: "Kill Terminal",
+          description: "Stop a running terminal process",
+          parameters: [
+            { name: "sessionId", in: "path", required: true, schema: { type: "string" } },
+            { name: "terminalId", in: "path", required: true, schema: { type: "string" } }
+          ],
+          requestBody: {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  properties: {
+                    signal: { type: "string", enum: ["SIGTERM", "SIGKILL"] }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            200: { description: "Terminal killed" },
+            400: { description: "Failed to kill terminal" }
+          }
+        }
+      },
+      "/sessions/{sessionId}/terminals/{terminalId}/write": {
+        post: {
+          summary: "Write to Terminal",
+          description: "Send input to terminal stdin",
+          parameters: [
+            { name: "sessionId", in: "path", required: true, schema: { type: "string" } },
+            { name: "terminalId", in: "path", required: true, schema: { type: "string" } }
+          ],
+          requestBody: {
+            content: {
+              "application/json": {
+                schema: {
+                  type: "object",
+                  required: ["input"],
+                  properties: {
+                    input: { type: "string" }
+                  }
+                }
+              }
+            }
+          },
+          responses: {
+            200: { description: "Input sent" },
+            400: { description: "Failed to write" }
+          }
+        }
+      },
+      "/sessions/{sessionId}/terminals/{terminalId}/stream": {
+        get: {
+          summary: "Stream Terminal Output",
+          description: "SSE stream of terminal output",
+          parameters: [
+            { name: "sessionId", in: "path", required: true, schema: { type: "string" } },
+            { name: "terminalId", in: "path", required: true, schema: { type: "string" } }
+          ],
+          responses: {
+            200: { description: "SSE stream", content: { "text/event-stream": {} } },
+            404: { description: "Terminal not found" }
+          }
+        }
+      },
+      "/sessions/{sessionId}/terminals/kill-all": {
+        post: {
+          summary: "Kill All Terminals",
+          description: "Stop all running terminals for a session",
+          parameters: [{ name: "sessionId", in: "path", required: true, schema: { type: "string" } }],
+          responses: {
+            200: { description: "Terminals killed" }
+          }
+        }
+      }
+    },
+    components: {
+      schemas: {
+        Session: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            name: { type: "string" },
+            workingDirectory: { type: "string" },
+            model: { type: "string" },
+            status: { type: "string", enum: ["active", "waiting", "completed", "error"] },
+            createdAt: { type: "string", format: "date-time" },
+            updatedAt: { type: "string", format: "date-time" }
+          }
+        },
+        Message: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            role: { type: "string", enum: ["user", "assistant", "system", "tool"] },
+            content: { type: "object" },
+            createdAt: { type: "string", format: "date-time" }
+          }
+        },
+        ToolExecution: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            toolCallId: { type: "string" },
+            toolName: { type: "string" },
+            input: { type: "object" },
+            output: { type: "object" },
+            status: { type: "string", enum: ["pending", "approved", "rejected", "completed", "error"] },
+            requiresApproval: { type: "boolean" }
+          }
+        },
+        Terminal: {
+          type: "object",
+          properties: {
+            id: { type: "string" },
+            name: { type: "string" },
+            command: { type: "string" },
+            cwd: { type: "string" },
+            pid: { type: "integer" },
+            status: { type: "string", enum: ["running", "stopped", "error"] },
+            exitCode: { type: "integer" },
+            error: { type: "string" },
+            createdAt: { type: "string", format: "date-time" },
+            stoppedAt: { type: "string", format: "date-time" }
+          }
+        }
+      }
+    }
+  };
+}
+export {
+  createApp,
+  startServer,
+  stopServer
+};
+//# sourceMappingURL=index.js.map