dorkos 0.1.0

package/dist/server/index.js

@@ -0,0 +1,4341 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../../apps/server/src/index.ts
+import dotenv from "dotenv";
+import path9 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+
+// ../../apps/server/src/app.ts
+import express from "express";
+import cors from "cors";
+import path8 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { apiReference } from "@scalar/express-api-reference";
+
+// ../../apps/server/src/routes/sessions.ts
+import path3 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Router } from "express";
+
+// ../../apps/server/src/services/agent-manager.ts
+import path from "path";
+import { fileURLToPath } from "url";
+import { execFileSync } from "child_process";
+import { existsSync } from "fs";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var INTERACTION_TIMEOUT_MS = 10 * 60 * 1e3;
+function resolveClaudeCliPath() {
+  try {
+    const sdkCli = __require.resolve("@anthropic-ai/claude-agent-sdk/cli.js");
+    if (existsSync(sdkCli)) return sdkCli;
+  } catch {
+  }
+  try {
+    const bin = execFileSync("which", ["claude"], { encoding: "utf-8" }).trim();
+    if (bin && existsSync(bin)) return bin;
+  } catch {
+  }
+  return void 0;
+}
+function handleAskUserQuestion(session, toolUseId, input) {
+  session.eventQueue.push({
+    type: "question_prompt",
+    data: {
+      toolCallId: toolUseId,
+      questions: input.questions
+    }
+  });
+  session.eventQueueNotify?.();
+  return new Promise((resolve3) => {
+    const timeout = setTimeout(() => {
+      session.pendingInteractions.delete(toolUseId);
+      resolve3({ behavior: "deny", message: "User did not respond within 10 minutes" });
+    }, INTERACTION_TIMEOUT_MS);
+    session.pendingInteractions.set(toolUseId, {
+      type: "question",
+      toolCallId: toolUseId,
+      resolve: (answers) => {
+        clearTimeout(timeout);
+        session.pendingInteractions.delete(toolUseId);
+        resolve3({
+          behavior: "allow",
+          updatedInput: { ...input, answers }
+        });
+      },
+      reject: () => {
+        clearTimeout(timeout);
+        session.pendingInteractions.delete(toolUseId);
+        resolve3({ behavior: "deny", message: "Interaction cancelled" });
+      },
+      timeout
+    });
+  });
+}
+function handleToolApproval(session, toolUseId, toolName, input) {
+  session.eventQueue.push({
+    type: "approval_required",
+    data: {
+      toolCallId: toolUseId,
+      toolName,
+      input: JSON.stringify(input)
+    }
+  });
+  session.eventQueueNotify?.();
+  return new Promise((resolve3) => {
+    const timeout = setTimeout(() => {
+      session.pendingInteractions.delete(toolUseId);
+      resolve3({ behavior: "deny", message: "Tool approval timed out after 10 minutes" });
+    }, INTERACTION_TIMEOUT_MS);
+    session.pendingInteractions.set(toolUseId, {
+      type: "approval",
+      toolCallId: toolUseId,
+      resolve: (approved) => {
+        clearTimeout(timeout);
+        session.pendingInteractions.delete(toolUseId);
+        resolve3(
+          approved ? { behavior: "allow", updatedInput: input } : { behavior: "deny", message: "User denied tool execution" }
+        );
+      },
+      reject: () => {
+        clearTimeout(timeout);
+        session.pendingInteractions.delete(toolUseId);
+        resolve3({ behavior: "deny", message: "Interaction cancelled" });
+      },
+      timeout
+    });
+  });
+}
+var TASK_TOOL_NAMES = /* @__PURE__ */ new Set(["TaskCreate", "TaskUpdate", "TaskList", "TaskGet"]);
+function buildTaskEvent(toolName, input) {
+  switch (toolName) {
+    case "TaskCreate":
+      return {
+        action: "create",
+        task: {
+          id: "",
+          subject: input.subject ?? "",
+          description: input.description,
+          activeForm: input.activeForm,
+          status: "pending"
+        }
+      };
+    case "TaskUpdate": {
+      const task = {
+        id: input.taskId ?? "",
+        subject: input.subject ?? "",
+        status: input.status ?? ""
+      };
+      if (input.activeForm) task.activeForm = input.activeForm;
+      if (input.description) task.description = input.description;
+      if (input.addBlockedBy) task.blockedBy = input.addBlockedBy;
+      if (input.addBlocks) task.blocks = input.addBlocks;
+      if (input.owner) task.owner = input.owner;
+      return { action: "update", task };
+    }
+    default:
+      return null;
+  }
+}
+var AgentManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  sessionLocks = /* @__PURE__ */ new Map();
+  SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+  // 30 minutes
+  LOCK_TTL_MS = 5 * 60 * 1e3;
+  // 5 minutes
+  cwd;
+  claudeCliPath;
+  constructor(cwd) {
+    this.cwd = cwd ?? process.env.GATEWAY_CWD ?? path.resolve(__dirname, "../../../../");
+    this.claudeCliPath = resolveClaudeCliPath();
+  }
+  /**
+   * Start or resume an agent session.
+   * For new sessions, sdkSessionId is assigned after the first query() init message.
+   * For resumed sessions, the sessionId IS the sdkSessionId.
+   */
+  ensureSession(sessionId, opts) {
+    if (!this.sessions.has(sessionId)) {
+      this.sessions.set(sessionId, {
+        sdkSessionId: sessionId,
+        lastActivity: Date.now(),
+        permissionMode: opts.permissionMode,
+        cwd: opts.cwd,
+        hasStarted: opts.hasStarted ?? false,
+        pendingInteractions: /* @__PURE__ */ new Map(),
+        eventQueue: []
+      });
+    }
+  }
+  async *sendMessage(sessionId, content, opts) {
+    if (!this.sessions.has(sessionId)) {
+      this.ensureSession(sessionId, {
+        permissionMode: opts?.permissionMode ?? "default",
+        cwd: opts?.cwd,
+        hasStarted: true
+      });
+    }
+    const session = this.sessions.get(sessionId);
+    session.lastActivity = Date.now();
+    session.eventQueue = [];
+    const sdkOptions = {
+      cwd: session.cwd ?? this.cwd,
+      includePartialMessages: true,
+      settingSources: ["project", "user"],
+      ...this.claudeCliPath ? { pathToClaudeCodeExecutable: this.claudeCliPath } : {}
+    };
+    if (session.hasStarted) {
+      sdkOptions.resume = session.sdkSessionId;
+    }
+    console.log(`[sendMessage] session=${sessionId} permissionMode=${session.permissionMode} hasStarted=${session.hasStarted} resume=${session.hasStarted ? session.sdkSessionId : "N/A"}`);
+    switch (session.permissionMode) {
+      case "bypassPermissions":
+        sdkOptions.permissionMode = "bypassPermissions";
+        sdkOptions.allowDangerouslySkipPermissions = true;
+        break;
+      case "plan":
+        sdkOptions.permissionMode = "plan";
+        break;
+      case "acceptEdits":
+        sdkOptions.permissionMode = "acceptEdits";
+        break;
+      default:
+        sdkOptions.permissionMode = "default";
+    }
+    if (session.model) {
+      sdkOptions.model = session.model;
+    }
+    sdkOptions.canUseTool = async (toolName, input, context) => {
+      if (toolName === "AskUserQuestion") {
+        console.log(`[canUseTool] ${toolName} \u2192 routing to question handler (toolUseID=${context.toolUseID})`);
+        return handleAskUserQuestion(session, context.toolUseID, input);
+      }
+      if (session.permissionMode === "default") {
+        console.log(`[canUseTool] ${toolName} \u2192 requesting approval (permissionMode=default, toolUseID=${context.toolUseID})`);
+        return handleToolApproval(session, context.toolUseID, toolName, input);
+      }
+      console.log(`[canUseTool] ${toolName} \u2192 auto-allow (permissionMode=${session.permissionMode}, toolUseID=${context.toolUseID})`);
+      return { behavior: "allow", updatedInput: input };
+    };
+    const agentQuery = query({ prompt: content, options: sdkOptions });
+    session.activeQuery = agentQuery;
+    let inTool = false;
+    let currentToolName = "";
+    let currentToolId = "";
+    let emittedDone = false;
+    let taskToolInput = "";
+    const toolState = {
+      get inTool() {
+        return inTool;
+      },
+      get currentToolName() {
+        return currentToolName;
+      },
+      get currentToolId() {
+        return currentToolId;
+      },
+      get taskToolInput() {
+        return taskToolInput;
+      },
+      appendTaskInput: (chunk) => {
+        taskToolInput += chunk;
+      },
+      resetTaskInput: () => {
+        taskToolInput = "";
+      },
+      setToolState: (tool, name, id) => {
+        inTool = tool;
+        currentToolName = name;
+        currentToolId = id;
+      }
+    };
+    try {
+      const sdkIterator = agentQuery[Symbol.asyncIterator]();
+      let pendingSdkPromise = null;
+      while (true) {
+        while (session.eventQueue.length > 0) {
+          const queuedEvent = session.eventQueue.shift();
+          if (queuedEvent.type === "done") emittedDone = true;
+          yield queuedEvent;
+        }
+        const queuePromise = new Promise((resolve3) => {
+          session.eventQueueNotify = () => resolve3("queue");
+        });
+        if (!pendingSdkPromise) {
+          pendingSdkPromise = sdkIterator.next().then((result2) => ({ sdk: true, result: result2 }));
+        }
+        const winner = await Promise.race([queuePromise, pendingSdkPromise]);
+        if (winner === "queue") {
+          continue;
+        }
+        pendingSdkPromise = null;
+        const { result } = winner;
+        if (result.done) break;
+        for await (const event of this.mapSdkMessage(result.value, session, sessionId, toolState)) {
+          if (event.type === "done") emittedDone = true;
+          yield event;
+        }
+      }
+    } catch (err) {
+      yield {
+        type: "error",
+        data: {
+          message: err instanceof Error ? err.message : "SDK error"
+        }
+      };
+    } finally {
+      session.activeQuery = void 0;
+    }
+    if (!emittedDone) {
+      yield {
+        type: "done",
+        data: { sessionId }
+      };
+    }
+  }
+  async *mapSdkMessage(message, session, sessionId, toolState) {
+    if (message.type === "system" && "subtype" in message && message.subtype === "init") {
+      session.sdkSessionId = message.session_id;
+      session.hasStarted = true;
+      const initModel = message.model;
+      if (initModel) {
+        yield {
+          type: "session_status",
+          data: {
+            sessionId,
+            model: initModel
+          }
+        };
+      }
+      return;
+    }
+    if (message.type === "stream_event") {
+      const event = message.event;
+      const eventType = event.type;
+      if (eventType === "content_block_start") {
+        const contentBlock = event.content_block;
+        if (contentBlock?.type === "tool_use") {
+          toolState.resetTaskInput();
+          toolState.setToolState(true, contentBlock.name, contentBlock.id);
+          yield {
+            type: "tool_call_start",
+            data: {
+              toolCallId: contentBlock.id,
+              toolName: contentBlock.name,
+              status: "running"
+            }
+          };
+        }
+      } else if (eventType === "content_block_delta") {
+        const delta = event.delta;
+        if (delta?.type === "text_delta" && !toolState.inTool) {
+          yield { type: "text_delta", data: { text: delta.text } };
+        } else if (delta?.type === "input_json_delta" && toolState.inTool) {
+          if (TASK_TOOL_NAMES.has(toolState.currentToolName)) {
+            toolState.appendTaskInput(delta.partial_json);
+          }
+          yield {
+            type: "tool_call_delta",
+            data: {
+              toolCallId: toolState.currentToolId,
+              toolName: toolState.currentToolName,
+              input: delta.partial_json,
+              status: "running"
+            }
+          };
+        }
+      } else if (eventType === "content_block_stop") {
+        if (toolState.inTool) {
+          const wasTaskTool = TASK_TOOL_NAMES.has(toolState.currentToolName);
+          const taskToolName = toolState.currentToolName;
+          yield {
+            type: "tool_call_end",
+            data: {
+              toolCallId: toolState.currentToolId,
+              toolName: toolState.currentToolName,
+              status: "complete"
+            }
+          };
+          toolState.setToolState(false, "", "");
+          if (wasTaskTool && toolState.taskToolInput) {
+            try {
+              const input = JSON.parse(toolState.taskToolInput);
+              const taskEvent = buildTaskEvent(taskToolName, input);
+              if (taskEvent) {
+                yield { type: "task_update", data: taskEvent };
+              }
+            } catch {
+            }
+            toolState.resetTaskInput();
+          }
+        }
+      }
+      return;
+    }
+    if (message.type === "tool_use_summary") {
+      const summary = message;
+      for (const toolUseId of summary.preceding_tool_use_ids) {
+        yield {
+          type: "tool_result",
+          data: {
+            toolCallId: toolUseId,
+            toolName: "",
+            result: summary.summary,
+            status: "complete"
+          }
+        };
+      }
+      return;
+    }
+    if (message.type === "result") {
+      const result = message;
+      const usage = result.usage;
+      const modelUsageMap = result.modelUsage;
+      const firstModelUsage = modelUsageMap ? Object.values(modelUsageMap)[0] : void 0;
+      yield {
+        type: "session_status",
+        data: {
+          sessionId,
+          model: result.model,
+          costUsd: result.total_cost_usd,
+          contextTokens: usage?.input_tokens,
+          contextMaxTokens: firstModelUsage?.contextWindow
+        }
+      };
+      yield {
+        type: "done",
+        data: { sessionId }
+      };
+    }
+  }
+  updateSession(sessionId, opts) {
+    let session = this.findSession(sessionId);
+    if (!session) {
+      this.ensureSession(sessionId, {
+        permissionMode: opts.permissionMode ?? "default",
+        hasStarted: true
+      });
+      session = this.sessions.get(sessionId);
+    }
+    if (opts.permissionMode) {
+      console.log(`[updateSession] ${sessionId} permissionMode: ${session.permissionMode} \u2192 ${opts.permissionMode}`);
+      session.permissionMode = opts.permissionMode;
+      if (session.activeQuery) {
+        console.log(`[updateSession] ${sessionId} calling setPermissionMode(${opts.permissionMode}) on active query`);
+        session.activeQuery.setPermissionMode(opts.permissionMode).catch((err) => {
+          console.error(`[updateSession] setPermissionMode failed:`, err);
+        });
+      }
+    }
+    if (opts.model) {
+      session.model = opts.model;
+    }
+    return true;
+  }
+  approveTool(sessionId, toolCallId, approved) {
+    const session = this.findSession(sessionId);
+    const pending = session?.pendingInteractions.get(toolCallId);
+    if (!pending || pending.type !== "approval") {
+      console.log(`[approveTool] ${sessionId} toolCallId=${toolCallId} approved=${approved} \u2192 NOT FOUND (session=${!!session}, pending=${!!pending}, type=${pending?.type})`);
+      return false;
+    }
+    console.log(`[approveTool] ${sessionId} toolCallId=${toolCallId} approved=${approved} \u2192 resolving`);
+    pending.resolve(approved);
+    return true;
+  }
+  submitAnswers(sessionId, toolCallId, answers) {
+    const session = this.findSession(sessionId);
+    const pending = session?.pendingInteractions.get(toolCallId);
+    if (!pending || pending.type !== "question") return false;
+    pending.resolve(answers);
+    return true;
+  }
+  checkSessionHealth() {
+    const now = Date.now();
+    for (const [id, session] of this.sessions) {
+      if (now - session.lastActivity > this.SESSION_TIMEOUT_MS) {
+        for (const interaction of session.pendingInteractions.values()) {
+          clearTimeout(interaction.timeout);
+        }
+        this.sessions.delete(id);
+        this.sessionLocks.delete(id);
+      }
+    }
+    for (const [id, lock] of this.sessionLocks) {
+      if (now - lock.acquiredAt > lock.ttl) {
+        this.sessionLocks.delete(id);
+      }
+    }
+  }
+  /**
+   * Find a session by its map key OR by its sdkSessionId.
+   * After the SDK assigns a real session ID (on first message), the client
+   * starts using the new ID while the map still stores it under the original key.
+   */
+  findSession(sessionId) {
+    const direct = this.sessions.get(sessionId);
+    if (direct) return direct;
+    for (const session of this.sessions.values()) {
+      if (session.sdkSessionId === sessionId) return session;
+    }
+    return void 0;
+  }
+  hasSession(sessionId) {
+    return !!this.findSession(sessionId);
+  }
+  /**
+   * Get the actual SDK session ID (may differ from input if SDK assigned a new one).
+   */
+  getSdkSessionId(sessionId) {
+    return this.findSession(sessionId)?.sdkSessionId;
+  }
+  /**
+   * Attempt to acquire a lock on a session for a specific client.
+   * Returns true if the lock was acquired, false if the session is locked by another client.
+   */
+  acquireLock(sessionId, clientId, res) {
+    const existing = this.sessionLocks.get(sessionId);
+    if (existing) {
+      const expired = Date.now() - existing.acquiredAt > existing.ttl;
+      if (expired) {
+        this.sessionLocks.delete(sessionId);
+      } else if (existing.clientId !== clientId) {
+        return false;
+      }
+    }
+    const lock = {
+      clientId,
+      acquiredAt: Date.now(),
+      ttl: this.LOCK_TTL_MS,
+      response: res
+    };
+    this.sessionLocks.set(sessionId, lock);
+    res.on("close", () => {
+      const current = this.sessionLocks.get(sessionId);
+      if (current === lock) {
+        this.sessionLocks.delete(sessionId);
+      }
+    });
+    return true;
+  }
+  /**
+   * Release a lock on a session if it's held by the specified client.
+   */
+  releaseLock(sessionId, clientId) {
+    const lock = this.sessionLocks.get(sessionId);
+    if (lock && lock.clientId === clientId) {
+      this.sessionLocks.delete(sessionId);
+    }
+  }
+  /**
+   * Check if a session is locked.
+   * If clientId is provided, returns false if the lock is held by that client (owns the lock).
+   * Returns true if the session is locked by another client.
+   */
+  isLocked(sessionId, clientId) {
+    const lock = this.sessionLocks.get(sessionId);
+    if (!lock) return false;
+    if (Date.now() - lock.acquiredAt > lock.ttl) {
+      this.sessionLocks.delete(sessionId);
+      return false;
+    }
+    if (clientId && lock.clientId === clientId) return false;
+    return true;
+  }
+  /**
+   * Get information about the current lock on a session.
+   * Returns null if the session is not locked or the lock has expired.
+   */
+  getLockInfo(sessionId) {
+    const lock = this.sessionLocks.get(sessionId);
+    if (!lock) return null;
+    if (Date.now() - lock.acquiredAt > lock.ttl) {
+      this.sessionLocks.delete(sessionId);
+      return null;
+    }
+    return { clientId: lock.clientId, acquiredAt: lock.acquiredAt };
+  }
+};
+var agentManager = new AgentManager();
+
+// ../../apps/server/src/services/transcript-reader.ts
+import fs from "fs/promises";
+import path2 from "path";
+import os from "os";
+var TranscriptReader = class {
+  metaCache = /* @__PURE__ */ new Map();
+  getProjectSlug(cwd) {
+    return cwd.replace(/[^a-zA-Z0-9-]/g, "-");
+  }
+  getTranscriptsDir(vaultRoot2) {
+    const slug = this.getProjectSlug(vaultRoot2);
+    return path2.join(os.homedir(), ".claude", "projects", slug);
+  }
+  /**
+   * List all sessions by scanning SDK JSONL transcript files.
+   * Extracts metadata (title, timestamps, preview) from file content and stats.
+   */
+  async listSessions(vaultRoot2) {
+    const transcriptsDir = this.getTranscriptsDir(vaultRoot2);
+    let files;
+    try {
+      files = (await fs.readdir(transcriptsDir)).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      return [];
+    }
+    const sessions = [];
+    for (const file of files) {
+      const sessionId = file.replace(".jsonl", "");
+      const filePath = path2.join(transcriptsDir, file);
+      try {
+        const fileStat = await fs.stat(filePath);
+        const cached = this.metaCache.get(sessionId);
+        if (cached && cached.mtimeMs === fileStat.mtimeMs) {
+          sessions.push(cached.session);
+          continue;
+        }
+        const meta = await this.extractSessionMeta(filePath, sessionId, fileStat);
+        this.metaCache.set(sessionId, { session: meta, mtimeMs: fileStat.mtimeMs });
+        sessions.push(meta);
+      } catch {
+      }
+    }
+    sessions.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return sessions;
+  }
+  /**
+   * Get metadata for a single session.
+   * Reads both head (for title/timestamps) and tail (for latest model/context).
+   */
+  async getSession(vaultRoot2, sessionId) {
+    const filePath = path2.join(this.getTranscriptsDir(vaultRoot2), `${sessionId}.jsonl`);
+    try {
+      const session = await this.extractSessionMeta(filePath, sessionId);
+      const tailStatus = await this.readTailStatus(filePath);
+      if (tailStatus.model) session.model = tailStatus.model;
+      if (tailStatus.permissionMode) session.permissionMode = tailStatus.permissionMode;
+      if (tailStatus.contextTokens) session.contextTokens = tailStatus.contextTokens;
+      return session;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Read the tail of a JSONL file to get the most recent model, permissionMode, and context tokens.
+   * Reads the last ~16KB which typically contains the final assistant messages.
+   */
+  async readTailStatus(filePath) {
+    const TAIL_SIZE = 16384;
+    try {
+      const stat4 = await fs.stat(filePath);
+      const fileHandle = await fs.open(filePath, "r");
+      try {
+        const readOffset = Math.max(0, stat4.size - TAIL_SIZE);
+        const buffer = Buffer.alloc(Math.min(TAIL_SIZE, stat4.size));
+        const { bytesRead } = await fileHandle.read(buffer, 0, buffer.length, readOffset);
+        const chunk = buffer.toString("utf-8", 0, bytesRead);
+        const lines = chunk.split("\n").filter((l) => l.trim());
+        let model;
+        let permissionMode;
+        let contextTokens;
+        for (const line of lines) {
+          let parsed;
+          try {
+            parsed = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (parsed.type === "assistant" && parsed.message?.model) {
+            model = parsed.message.model;
+            if (parsed.message.usage) {
+              const u = parsed.message.usage;
+              contextTokens = (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+            }
+          }
+          if (parsed.type === "user" && parsed.permissionMode) {
+            const sdkMode = parsed.permissionMode;
+            if (sdkMode === "bypassPermissions" || sdkMode === "dangerously-skip") {
+              permissionMode = "bypassPermissions";
+            } else if (sdkMode === "plan") {
+              permissionMode = "plan";
+            } else if (sdkMode === "acceptEdits") {
+              permissionMode = "acceptEdits";
+            } else {
+              permissionMode = "default";
+            }
+          }
+        }
+        return { model, permissionMode, contextTokens };
+      } finally {
+        await fileHandle.close();
+      }
+    } catch {
+      return {};
+    }
+  }
+  /**
+   * Extract session metadata from a JSONL file.
+   * Reads only the first ~8KB for title/permissionMode, and uses file stat for timestamps.
+   */
+  async extractSessionMeta(filePath, sessionId, fileStat) {
+    const stat4 = fileStat ?? await fs.stat(filePath);
+    const fileHandle = await fs.open(filePath, "r");
+    let chunk;
+    try {
+      const buffer = Buffer.alloc(8192);
+      const { bytesRead } = await fileHandle.read(buffer, 0, 8192, 0);
+      chunk = buffer.toString("utf-8", 0, bytesRead);
+    } finally {
+      await fileHandle.close();
+    }
+    const lines = chunk.split("\n").filter((l) => l.trim());
+    let firstUserMessage = "";
+    let permissionMode = "default";
+    let firstTimestamp = "";
+    let model;
+    let cwd;
+    for (const line of lines) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (parsed.type === "system" && parsed.subtype === "init" && parsed.permissionMode) {
+        const sdkMode = parsed.permissionMode;
+        if (sdkMode === "bypassPermissions" || sdkMode === "dangerously-skip") {
+          permissionMode = "bypassPermissions";
+        } else if (sdkMode === "plan") {
+          permissionMode = "plan";
+        } else if (sdkMode === "acceptEdits") {
+          permissionMode = "acceptEdits";
+        }
+      }
+      if (parsed.type === "user" && parsed.permissionMode) {
+        const sdkMode = parsed.permissionMode;
+        if (sdkMode === "bypassPermissions" || sdkMode === "dangerously-skip") {
+          permissionMode = "bypassPermissions";
+        } else if (sdkMode === "plan") {
+          permissionMode = "plan";
+        } else if (sdkMode === "acceptEdits") {
+          permissionMode = "acceptEdits";
+        } else {
+          permissionMode = "default";
+        }
+      }
+      if (!model && parsed.type === "assistant" && parsed.message?.model) {
+        model = parsed.message.model;
+      }
+      if (parsed.timestamp && !firstTimestamp) {
+        firstTimestamp = parsed.timestamp;
+      }
+      if (!cwd && parsed.cwd) {
+        cwd = parsed.cwd;
+      }
+      if (!firstUserMessage && parsed.type === "user" && parsed.message) {
+        const text = this.extractTextContent(parsed.message.content);
+        if (text.startsWith("<local-command") || text.startsWith("<command-name>") || text.startsWith("<command-message>") || text.startsWith("<task-notification>")) {
+          continue;
+        }
+        if (text.startsWith("This session is being continued")) {
+          continue;
+        }
+        const cleanText = this.stripSystemTags(text);
+        if (!cleanText.trim()) continue;
+        firstUserMessage = cleanText.trim();
+      }
+      if (firstUserMessage && firstTimestamp && model && cwd) break;
+    }
+    const title = firstUserMessage ? firstUserMessage.slice(0, 80) + (firstUserMessage.length > 80 ? "..." : "") : `Session ${sessionId.slice(0, 8)}`;
+    return {
+      id: sessionId,
+      title,
+      createdAt: firstTimestamp || stat4.birthtime.toISOString(),
+      updatedAt: stat4.mtime.toISOString(),
+      lastMessagePreview: void 0,
+      permissionMode,
+      model,
+      cwd
+    };
+  }
+  /**
+   * Read messages from an SDK session transcript.
+   */
+  async readTranscript(vaultRoot2, sessionId) {
+    const transcriptsDir = this.getTranscriptsDir(vaultRoot2);
+    const filePath = path2.join(transcriptsDir, `${sessionId}.jsonl`);
+    let content;
+    try {
+      content = await fs.readFile(filePath, "utf-8");
+    } catch {
+      return [];
+    }
+    const messages = [];
+    const lines = content.split("\n").filter((l) => l.trim());
+    let pendingCommand = null;
+    let pendingSkillArgs = null;
+    const toolCallMap = /* @__PURE__ */ new Map();
+    const toolCallPartMap = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (parsed.type === "user" && parsed.message) {
+        const msgContent = parsed.message.content;
+        if (Array.isArray(msgContent)) {
+          let hasToolResult = false;
+          const textParts = [];
+          const sdkAnswers = parsed.toolUseResult?.answers;
+          for (const block of msgContent) {
+            if (block.type === "tool_result" && block.tool_use_id) {
+              hasToolResult = true;
+              const resultText = this.extractToolResultContent(block.content);
+              const tc = toolCallMap.get(block.tool_use_id);
+              if (tc) {
+                tc.result = resultText;
+                if (tc.toolName === "AskUserQuestion" && tc.questions && !tc.answers) {
+                  tc.answers = sdkAnswers ? this.mapSdkAnswersToIndices(sdkAnswers, tc.questions) : this.parseQuestionAnswers(resultText, tc.questions);
+                }
+              }
+              const tcPart = toolCallPartMap.get(block.tool_use_id);
+              if (tcPart) {
+                tcPart.result = resultText;
+                if (tcPart.toolName === "AskUserQuestion" && tcPart.questions && !tcPart.answers) {
+                  tcPart.answers = sdkAnswers ? this.mapSdkAnswersToIndices(sdkAnswers, tcPart.questions) : this.parseQuestionAnswers(resultText, tcPart.questions);
+                }
+              }
+            } else if (block.type === "text" && block.text) {
+              textParts.push(block.text);
+            }
+          }
+          if (hasToolResult && textParts.length === 0) {
+            if (parsed.toolUseResult?.commandName) {
+              const cmdName = "/" + parsed.toolUseResult.commandName.replace(/^\//, "");
+              pendingCommand = { commandName: cmdName, commandArgs: pendingSkillArgs || "" };
+              pendingSkillArgs = null;
+            }
+            continue;
+          }
+          if (pendingCommand) {
+            const { commandName, commandArgs } = pendingCommand;
+            pendingCommand = null;
+            const displayContent = commandArgs ? `${commandName} ${commandArgs}` : commandName;
+            messages.push({
+              id: parsed.uuid || crypto.randomUUID(),
+              role: "user",
+              content: displayContent,
+              messageType: "command",
+              commandName,
+              commandArgs: commandArgs || void 0
+            });
+            continue;
+          }
+          if (textParts.length > 0) {
+            const cleanText2 = this.stripSystemTags(textParts.join("\n"));
+            if (cleanText2.trim()) {
+              messages.push({
+                id: parsed.uuid || crypto.randomUUID(),
+                role: "user",
+                content: cleanText2
+              });
+            }
+          }
+          continue;
+        }
+        const text = typeof msgContent === "string" ? msgContent : "";
+        if (text.startsWith("<task-notification>")) {
+          continue;
+        }
+        if (text.startsWith("<command-message>") || text.startsWith("<command-name>")) {
+          const meta = this.extractCommandMeta(text);
+          if (meta) {
+            pendingCommand = meta;
+          }
+          continue;
+        }
+        if (text.startsWith("<local-command")) {
+          pendingCommand = null;
+          continue;
+        }
+        if (pendingCommand) {
+          const { commandName, commandArgs } = pendingCommand;
+          pendingCommand = null;
+          const displayContent = commandArgs ? `${commandName} ${commandArgs}` : commandName;
+          messages.push({
+            id: parsed.uuid || crypto.randomUUID(),
+            role: "user",
+            content: displayContent,
+            messageType: "command",
+            commandName,
+            commandArgs: commandArgs || void 0
+          });
+          continue;
+        }
+        if (text.startsWith("This session is being continued")) {
+          messages.push({
+            id: parsed.uuid || crypto.randomUUID(),
+            role: "user",
+            content: text,
+            messageType: "compaction"
+          });
+          continue;
+        }
+        const cleanText = this.stripSystemTags(text);
+        if (!cleanText.trim()) continue;
+        messages.push({
+          id: parsed.uuid || crypto.randomUUID(),
+          role: "user",
+          content: cleanText
+        });
+      } else if (parsed.type === "assistant" && parsed.message) {
+        const contentBlocks = parsed.message.content;
+        if (!Array.isArray(contentBlocks)) continue;
+        const parts = [];
+        const toolCalls = [];
+        for (const block of contentBlocks) {
+          if (block.type === "text" && block.text) {
+            const lastPart = parts[parts.length - 1];
+            if (lastPart && lastPart.type === "text") {
+              lastPart.text += "\n" + block.text;
+            } else {
+              parts.push({ type: "text", text: block.text });
+            }
+          } else if (block.type === "tool_use" && block.name && block.id) {
+            const tc = {
+              toolCallId: block.id,
+              toolName: block.name,
+              input: block.input ? JSON.stringify(block.input) : void 0,
+              status: "complete"
+            };
+            if (block.name === "AskUserQuestion" && block.input) {
+              if (Array.isArray(block.input.questions)) {
+                tc.questions = block.input.questions;
+              }
+              if (block.input.answers && typeof block.input.answers === "object") {
+                tc.answers = block.input.answers;
+              }
+            }
+            if (block.name === "Skill" && block.input) {
+              const input = block.input;
+              pendingSkillArgs = input.args || null;
+            }
+            toolCalls.push(tc);
+            toolCallMap.set(block.id, tc);
+            const toolCallPart = {
+              type: "tool_call",
+              toolCallId: block.id,
+              toolName: block.name,
+              input: block.input ? JSON.stringify(block.input) : void 0,
+              status: "complete",
+              ...tc.questions ? {
+                interactiveType: "question",
+                questions: tc.questions,
+                answers: tc.answers
+              } : {}
+            };
+            parts.push(toolCallPart);
+            toolCallPartMap.set(block.id, toolCallPart);
+          }
+        }
+        if (parts.length === 0) continue;
+        const text = parts.filter((p) => p.type === "text").map((p) => p.text).join("\n").trim();
+        messages.push({
+          id: parsed.uuid || crypto.randomUUID(),
+          role: "assistant",
+          content: text,
+          toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+          parts,
+          timestamp: parsed.timestamp
+        });
+      }
+    }
+    return messages;
+  }
+  /**
+   * List available SDK session transcript IDs.
+   */
+  async listTranscripts(vaultRoot2) {
+    const transcriptsDir = this.getTranscriptsDir(vaultRoot2);
+    try {
+      const files = await fs.readdir(transcriptsDir);
+      return files.filter((f) => f.endsWith(".jsonl")).map((f) => f.replace(".jsonl", ""));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Read task state from an SDK session transcript.
+   * Parses TaskCreate/TaskUpdate tool_use blocks and reconstructs final state.
+   */
+  async getTranscriptETag(vaultRoot2, sessionId) {
+    const filePath = path2.join(this.getTranscriptsDir(vaultRoot2), `${sessionId}.jsonl`);
+    try {
+      const stat4 = await fs.stat(filePath);
+      return `"${stat4.mtimeMs}-${stat4.size}"`;
+    } catch {
+      return null;
+    }
+  }
+  async readTasks(vaultRoot2, sessionId) {
+    const transcriptsDir = this.getTranscriptsDir(vaultRoot2);
+    const filePath = path2.join(transcriptsDir, `${sessionId}.jsonl`);
+    let content;
+    try {
+      content = await fs.readFile(filePath, "utf-8");
+    } catch {
+      return [];
+    }
+    const lines = content.split("\n").filter((l) => l.trim());
+    const tasks = /* @__PURE__ */ new Map();
+    let nextId = 1;
+    for (const line of lines) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (parsed.type !== "assistant") continue;
+      const message = parsed.message;
+      if (!message?.content || !Array.isArray(message.content)) continue;
+      for (const block of message.content) {
+        if (block.type !== "tool_use") continue;
+        if (!block.name || !["TaskCreate", "TaskUpdate"].includes(block.name)) continue;
+        const input = block.input;
+        if (!input) continue;
+        if (block.name === "TaskCreate") {
+          const id = String(nextId++);
+          tasks.set(id, {
+            id,
+            subject: input.subject ?? "",
+            description: input.description,
+            activeForm: input.activeForm,
+            status: "pending"
+          });
+        } else if (block.name === "TaskUpdate" && input.taskId) {
+          const existing = tasks.get(input.taskId);
+          if (existing) {
+            if (input.status) existing.status = input.status;
+            if (input.subject) existing.subject = input.subject;
+            if (input.activeForm) existing.activeForm = input.activeForm;
+            if (input.description) existing.description = input.description;
+            if (input.addBlockedBy) existing.blockedBy = [...existing.blockedBy ?? [], ...input.addBlockedBy];
+            if (input.addBlocks) existing.blocks = [...existing.blocks ?? [], ...input.addBlocks];
+            if (input.owner) existing.owner = input.owner;
+          }
+        }
+      }
+    }
+    return Array.from(tasks.values());
+  }
+  /**
+   * Read new content from a transcript file starting from a byte offset.
+   * Returns the new content and the updated file size (new offset).
+   */
+  async readFromOffset(vaultRoot2, sessionId, fromOffset) {
+    const filePath = path2.join(this.getTranscriptsDir(vaultRoot2), `${sessionId}.jsonl`);
+    const stat4 = await fs.stat(filePath);
+    if (stat4.size <= fromOffset) {
+      return { content: "", newOffset: fromOffset };
+    }
+    const fileHandle = await fs.open(filePath, "r");
+    try {
+      const newBytes = stat4.size - fromOffset;
+      const buffer = Buffer.alloc(newBytes);
+      await fileHandle.read(buffer, 0, newBytes, fromOffset);
+      return {
+        content: buffer.toString("utf-8"),
+        newOffset: stat4.size
+      };
+    } finally {
+      await fileHandle.close();
+    }
+  }
+  extractToolResultContent(content) {
+    if (!content) return "";
+    if (typeof content === "string") return content;
+    if (!Array.isArray(content)) return "";
+    return content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
+  }
+  extractTextContent(content) {
+    if (typeof content === "string") return content;
+    if (!Array.isArray(content)) return "";
+    return content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join("\n");
+  }
+  extractCommandMeta(text) {
+    const nameMatch = text.match(/<command-name>\/?([^<]+)<\/command-name>/);
+    if (!nameMatch) return null;
+    const commandName = "/" + nameMatch[1].replace(/^\//, "");
+    const argsMatch = text.match(/<command-args>([\s\S]*?)<\/command-args>/);
+    const commandArgs = argsMatch ? argsMatch[1].trim() : "";
+    return { commandName, commandArgs };
+  }
+  stripSystemTags(text) {
+    return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "").trim();
+  }
+  /**
+   * Map SDK's toolUseResult.answers (keyed by question text) to index-keyed record.
+   * SDK stores answers as { "Question text": "Answer value" }.
+   * Client expects { "0": "Answer value", "1": "..." }.
+   */
+  mapSdkAnswersToIndices(sdkAnswers, questions) {
+    const answers = {};
+    for (const [questionText, answerText] of Object.entries(sdkAnswers)) {
+      const qIdx = questions.findIndex((q) => q.question === questionText);
+      if (qIdx !== -1) {
+        answers[String(qIdx)] = answerText;
+      }
+    }
+    if (Object.keys(answers).length === 0) {
+      for (const [key, value] of Object.entries(sdkAnswers)) {
+        if (/^\d+$/.test(key)) {
+          answers[key] = value;
+        }
+      }
+    }
+    return answers;
+  }
+  /**
+   * Parse answers from AskUserQuestion tool_result text (fallback).
+   * Format: `..."Question text"="Answer text", "Q2"="A2". You can now...`
+   * Falls back to empty record (truthy signal) if parsing fails.
+   */
+  parseQuestionAnswers(resultText, questions) {
+    const answers = {};
+    const pairRegex = /"([^"]+?)"\s*=\s*"([^"]+?)"/g;
+    let match;
+    while ((match = pairRegex.exec(resultText)) !== null) {
+      const [, questionText, answerText] = match;
+      const qIdx = questions.findIndex((q) => q.question === questionText);
+      if (qIdx !== -1) {
+        answers[String(qIdx)] = answerText;
+      }
+    }
+    return answers;
+  }
+};
+var transcriptReader = new TranscriptReader();
+
+// ../../apps/server/src/services/stream-adapter.ts
+function initSSEStream(res) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+}
+function sendSSEEvent(res, event) {
+  res.write(`event: ${event.type}
+`);
+  res.write(`data: ${JSON.stringify(event.data)}
+
+`);
+}
+function endSSEStream(res) {
+  res.end();
+}
+
+// ../shared/dist/schemas.js
+import { z } from "zod";
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+extendZodWithOpenApi(z);
+var PermissionModeSchema = z.enum(["default", "plan", "acceptEdits", "bypassPermissions"]).openapi("PermissionMode");
+var TaskStatusSchema = z.enum(["pending", "in_progress", "completed"]).openapi("TaskStatus");
+var StreamEventTypeSchema = z.enum([
+  "text_delta",
+  "tool_call_start",
+  "tool_call_delta",
+  "tool_call_end",
+  "tool_result",
+  "approval_required",
+  "question_prompt",
+  "error",
+  "done",
+  "session_status",
+  "task_update",
+  "sync_update",
+  "sync_connected"
+]).openapi("StreamEventType");
+var QuestionOptionSchema = z.object({
+  label: z.string(),
+  description: z.string().optional()
+}).openapi("QuestionOption");
+var QuestionItemSchema = z.object({
+  header: z.string(),
+  question: z.string(),
+  options: z.array(QuestionOptionSchema),
+  multiSelect: z.boolean()
+}).openapi("QuestionItem");
+var SessionSchema = z.object({
+  id: z.string().uuid(),
+  title: z.string(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+  lastMessagePreview: z.string().optional(),
+  permissionMode: PermissionModeSchema,
+  model: z.string().optional(),
+  contextTokens: z.number().int().optional(),
+  cwd: z.string().optional()
+}).openapi("Session");
+var CreateSessionRequestSchema = z.object({
+  permissionMode: PermissionModeSchema.optional(),
+  cwd: z.string().optional()
+}).openapi("CreateSessionRequest");
+var UpdateSessionRequestSchema = z.object({
+  permissionMode: PermissionModeSchema.optional(),
+  model: z.string().optional()
+}).openapi("UpdateSessionRequest");
+var SendMessageRequestSchema = z.object({
+  content: z.string().min(1, "content is required"),
+  cwd: z.string().optional()
+}).openapi("SendMessageRequest");
+var ApprovalRequestSchema = z.object({
+  toolCallId: z.string()
+}).openapi("ApprovalRequest");
+var SubmitAnswersRequestSchema = z.object({
+  toolCallId: z.string(),
+  answers: z.record(z.string(), z.string())
+}).openapi("SubmitAnswersRequest");
+var ListSessionsQuerySchema = z.object({
+  limit: z.coerce.number().int().min(1).max(500).optional().default(200),
+  cwd: z.string().optional()
+}).openapi("ListSessionsQuery");
+var CommandsQuerySchema = z.object({
+  refresh: z.enum(["true", "false"]).optional(),
+  cwd: z.string().optional()
+}).openapi("CommandsQuery");
+var TextDeltaSchema = z.object({
+  text: z.string()
+}).openapi("TextDelta");
+var ToolCallStatusSchema = z.enum(["pending", "running", "complete", "error"]);
+var ToolCallEventSchema = z.object({
+  toolCallId: z.string(),
+  toolName: z.string(),
+  input: z.string().optional(),
+  result: z.string().optional(),
+  status: ToolCallStatusSchema
+}).openapi("ToolCallEvent");
+var ApprovalEventSchema = z.object({
+  toolCallId: z.string(),
+  toolName: z.string(),
+  input: z.string()
+}).openapi("ApprovalEvent");
+var QuestionPromptEventSchema = z.object({
+  toolCallId: z.string(),
+  questions: z.array(QuestionItemSchema)
+}).openapi("QuestionPromptEvent");
+var ErrorEventSchema = z.object({
+  message: z.string(),
+  code: z.string().optional()
+}).openapi("ErrorEvent");
+var DoneEventSchema = z.object({
+  sessionId: z.string()
+}).openapi("DoneEvent");
+var SessionStatusEventSchema = z.object({
+  sessionId: z.string(),
+  model: z.string().optional(),
+  costUsd: z.number().optional(),
+  contextTokens: z.number().int().optional(),
+  contextMaxTokens: z.number().int().optional()
+}).openapi("SessionStatusEvent");
+var TaskItemSchema = z.object({
+  id: z.string(),
+  subject: z.string(),
+  description: z.string().optional(),
+  activeForm: z.string().optional(),
+  status: TaskStatusSchema,
+  blockedBy: z.array(z.string()).optional(),
+  blocks: z.array(z.string()).optional(),
+  owner: z.string().optional()
+}).openapi("TaskItem");
+var TaskUpdateEventSchema = z.object({
+  action: z.enum(["create", "update", "snapshot"]),
+  task: TaskItemSchema
+}).openapi("TaskUpdateEvent");
+var SyncUpdateEventSchema = z.object({
+  sessionId: z.string(),
+  timestamp: z.string()
+}).openapi("SyncUpdateEvent");
+var SyncConnectedEventSchema = z.object({
+  sessionId: z.string()
+}).openapi("SyncConnectedEvent");
+var StreamEventSchema = z.object({
+  type: StreamEventTypeSchema,
+  data: z.union([
+    TextDeltaSchema,
+    ToolCallEventSchema,
+    ApprovalEventSchema,
+    QuestionPromptEventSchema,
+    ErrorEventSchema,
+    DoneEventSchema,
+    SessionStatusEventSchema,
+    TaskUpdateEventSchema,
+    SyncUpdateEventSchema,
+    SyncConnectedEventSchema
+  ])
+}).openapi("StreamEvent");
+var TextPartSchema = z.object({
+  type: z.literal("text"),
+  text: z.string()
+}).openapi("TextPart");
+var ToolCallPartSchema = z.object({
+  type: z.literal("tool_call"),
+  toolCallId: z.string(),
+  toolName: z.string(),
+  input: z.string().optional(),
+  result: z.string().optional(),
+  status: ToolCallStatusSchema,
+  interactiveType: z.enum(["approval", "question"]).optional(),
+  questions: z.array(QuestionItemSchema).optional(),
+  answers: z.record(z.string(), z.string()).optional()
+}).openapi("ToolCallPart");
+var MessagePartSchema = z.discriminatedUnion("type", [
+  TextPartSchema,
+  ToolCallPartSchema
+]);
+var MessageTypeSchema = z.enum(["command", "compaction"]).openapi("MessageType");
+var HistoryToolCallSchema = z.object({
+  toolCallId: z.string(),
+  toolName: z.string(),
+  input: z.string().optional(),
+  result: z.string().optional(),
+  status: z.literal("complete"),
+  questions: z.array(QuestionItemSchema).optional(),
+  answers: z.record(z.string(), z.string()).optional()
+}).openapi("HistoryToolCall");
+var HistoryMessageSchema = z.object({
+  id: z.string(),
+  role: z.enum(["user", "assistant"]),
+  content: z.string(),
+  toolCalls: z.array(HistoryToolCallSchema).optional(),
+  parts: z.array(MessagePartSchema).optional(),
+  timestamp: z.string().optional(),
+  messageType: MessageTypeSchema.optional(),
+  commandName: z.string().optional(),
+  commandArgs: z.string().optional()
+}).openapi("HistoryMessage");
+var CommandEntrySchema = z.object({
+  namespace: z.string(),
+  command: z.string(),
+  fullCommand: z.string(),
+  description: z.string(),
+  argumentHint: z.string().optional(),
+  allowedTools: z.array(z.string()).optional(),
+  filePath: z.string()
+}).openapi("CommandEntry");
+var CommandRegistrySchema = z.object({
+  commands: z.array(CommandEntrySchema),
+  lastScanned: z.string()
+}).openapi("CommandRegistry");
+var FileListQuerySchema = z.object({
+  cwd: z.string().min(1)
+}).openapi("FileListQuery");
+var FileListResponseSchema = z.object({
+  files: z.array(z.string()),
+  truncated: z.boolean(),
+  total: z.number().int()
+}).openapi("FileListResponse");
+var BrowseDirectoryQuerySchema = z.object({
+  path: z.string().min(1).optional(),
+  showHidden: z.coerce.boolean().optional().default(false)
+}).openapi("BrowseDirectoryQuery");
+var DirectoryEntrySchema = z.object({
+  name: z.string(),
+  path: z.string(),
+  isDirectory: z.boolean()
+}).openapi("DirectoryEntry");
+var BrowseDirectoryResponseSchema = z.object({
+  path: z.string(),
+  entries: z.array(DirectoryEntrySchema),
+  parent: z.string().nullable()
+}).openapi("BrowseDirectoryResponse");
+var TunnelStatusSchema = z.object({
+  connected: z.boolean(),
+  url: z.string().nullable(),
+  port: z.number().int().nullable(),
+  startedAt: z.string().nullable()
+}).openapi("TunnelStatus");
+var HealthResponseSchema = z.object({
+  status: z.string(),
+  version: z.string(),
+  uptime: z.number(),
+  tunnel: TunnelStatusSchema.optional()
+}).openapi("HealthResponse");
+var ServerConfigSchema = z.object({
+  version: z.string(),
+  port: z.number().int(),
+  uptime: z.number(),
+  workingDirectory: z.string(),
+  nodeVersion: z.string(),
+  claudeCliPath: z.string().nullable(),
+  tunnel: z.object({
+    enabled: z.boolean(),
+    connected: z.boolean(),
+    url: z.string().nullable(),
+    authEnabled: z.boolean(),
+    tokenConfigured: z.boolean()
+  })
+}).openapi("ServerConfig");
+var GitStatusResponseSchema = z.object({
+  branch: z.string().describe("Current branch name or HEAD SHA if detached"),
+  ahead: z.number().int().describe("Commits ahead of remote tracking branch"),
+  behind: z.number().int().describe("Commits behind remote tracking branch"),
+  modified: z.number().int().describe("Count of modified files (staged + unstaged)"),
+  staged: z.number().int().describe("Count of staged files"),
+  untracked: z.number().int().describe("Count of untracked files"),
+  conflicted: z.number().int().describe("Count of files with merge conflicts"),
+  clean: z.boolean().describe("True if working directory is clean"),
+  detached: z.boolean().describe("True if HEAD is detached"),
+  tracking: z.string().nullable().describe("Remote tracking branch name")
+}).openapi("GitStatusResponse");
+var GitStatusErrorSchema = z.object({
+  error: z.literal("not_git_repo")
+}).openapi("GitStatusError");
+var ErrorResponseSchema = z.object({
+  error: z.string(),
+  details: z.any().optional()
+}).openapi("ErrorResponse");
+var SessionLockedErrorSchema = z.object({
+  error: z.literal("Session locked"),
+  code: z.literal("SESSION_LOCKED"),
+  lockedBy: z.string(),
+  lockedAt: z.string()
+}).openapi("SessionLockedError");
+
+// ../../apps/server/src/routes/sessions.ts
+var __dirname2 = path3.dirname(fileURLToPath2(import.meta.url));
+var vaultRoot = path3.resolve(__dirname2, "../../../../");
+var router = Router();
+router.post("/", async (req, res) => {
+  const parsed = CreateSessionRequestSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid request", details: parsed.error.format() });
+  }
+  const { permissionMode = "default", cwd } = parsed.data;
+  const sessionId = crypto.randomUUID();
+  agentManager.ensureSession(sessionId, { permissionMode, cwd });
+  res.json({
+    id: sessionId,
+    title: `New Session`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    permissionMode,
+    cwd
+  });
+});
+router.get("/", async (req, res) => {
+  const parsed = ListSessionsQuerySchema.safeParse(req.query);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid query", details: parsed.error.format() });
+  }
+  const { limit, cwd } = parsed.data;
+  const projectDir = cwd || vaultRoot;
+  const sessions = await transcriptReader.listSessions(projectDir);
+  res.json(sessions.slice(0, limit));
+});
+router.get("/:id", async (req, res) => {
+  const cwd = req.query.cwd || vaultRoot;
+  const session = await transcriptReader.getSession(cwd, req.params.id);
+  if (!session) return res.status(404).json({ error: "Session not found" });
+  res.json(session);
+});
+router.get("/:id/tasks", async (req, res) => {
+  const cwd = req.query.cwd || vaultRoot;
+  const etag = await transcriptReader.getTranscriptETag(cwd, req.params.id);
+  if (etag) {
+    res.setHeader("ETag", etag);
+    if (req.headers["if-none-match"] === etag) {
+      return res.status(304).end();
+    }
+  }
+  try {
+    const tasks = await transcriptReader.readTasks(cwd, req.params.id);
+    res.json({ tasks });
+  } catch {
+    res.status(404).json({ error: "Session not found" });
+  }
+});
+router.get("/:id/messages", async (req, res) => {
+  const cwd = req.query.cwd || vaultRoot;
+  const etag = await transcriptReader.getTranscriptETag(cwd, req.params.id);
+  if (etag) {
+    res.setHeader("ETag", etag);
+    if (req.headers["if-none-match"] === etag) {
+      return res.status(304).end();
+    }
+  }
+  const messages = await transcriptReader.readTranscript(cwd, req.params.id);
+  res.json({ messages });
+});
+router.patch("/:id", async (req, res) => {
+  const parsed = UpdateSessionRequestSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid request", details: parsed.error.format() });
+  }
+  const { permissionMode, model } = parsed.data;
+  const updated = agentManager.updateSession(req.params.id, { permissionMode, model });
+  if (!updated) return res.status(404).json({ error: "Session not found" });
+  const cwd = req.query.cwd || vaultRoot;
+  const session = await transcriptReader.getSession(cwd, req.params.id);
+  if (session) {
+    session.permissionMode = permissionMode ?? session.permissionMode;
+    session.model = model ?? session.model;
+  }
+  res.json(session ?? { id: req.params.id, permissionMode, model });
+});
+router.post("/:id/messages", async (req, res) => {
+  const parsed = SendMessageRequestSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid request", details: parsed.error.format() });
+  }
+  const { content, cwd } = parsed.data;
+  const sessionId = req.params.id;
+  const clientId = req.headers["x-client-id"] || crypto.randomUUID();
+  const lockAcquired = agentManager.acquireLock(sessionId, clientId, res);
+  if (!lockAcquired) {
+    const lockInfo = agentManager.getLockInfo(sessionId);
+    return res.status(409).json({
+      error: "Session locked",
+      code: "SESSION_LOCKED",
+      lockedBy: lockInfo?.clientId ?? "unknown",
+      lockedAt: lockInfo ? new Date(lockInfo.acquiredAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  res.on("close", () => {
+    agentManager.releaseLock(sessionId, clientId);
+  });
+  initSSEStream(res);
+  try {
+    for await (const event of agentManager.sendMessage(sessionId, content, { cwd })) {
+      sendSSEEvent(res, event);
+      if (event.type === "done") {
+        const actualSdkId = agentManager.getSdkSessionId(sessionId);
+        if (actualSdkId && actualSdkId !== sessionId) {
+          sendSSEEvent(res, {
+            type: "done",
+            data: { sessionId: actualSdkId }
+          });
+        }
+      }
+    }
+  } catch (err) {
+    sendSSEEvent(res, {
+      type: "error",
+      data: { message: err instanceof Error ? err.message : "Unknown error" }
+    });
+  } finally {
+    agentManager.releaseLock(sessionId, clientId);
+    endSSEStream(res);
+  }
+});
+router.post("/:id/approve", async (req, res) => {
+  const parsed = ApprovalRequestSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid request", details: parsed.error.format() });
+  }
+  const { toolCallId } = parsed.data;
+  const approved = agentManager.approveTool(req.params.id, toolCallId, true);
+  if (!approved) return res.status(404).json({ error: "No pending approval" });
+  res.json({ ok: true });
+});
+router.post("/:id/deny", async (req, res) => {
+  const parsed = ApprovalRequestSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid request", details: parsed.error.format() });
+  }
+  const { toolCallId } = parsed.data;
+  const denied = agentManager.approveTool(req.params.id, toolCallId, false);
+  if (!denied) return res.status(404).json({ error: "No pending approval" });
+  res.json({ ok: true });
+});
+router.post("/:id/submit-answers", async (req, res) => {
+  const parsed = SubmitAnswersRequestSchema.safeParse(req.body);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid request", details: parsed.error.format() });
+  }
+  const { toolCallId, answers } = parsed.data;
+  const ok = agentManager.submitAnswers(req.params.id, toolCallId, answers);
+  if (!ok) return res.status(404).json({ error: "No pending question" });
+  res.json({ ok: true });
+});
+router.get("/:id/stream", (req, res) => {
+  const sessionId = req.params.id;
+  const cwd = req.query.cwd || vaultRoot;
+  const sessionBroadcaster2 = req.app.locals.sessionBroadcaster;
+  res.setHeader("Content-Type", "text/event-stream");
+  res.setHeader("Cache-Control", "no-cache");
+  res.setHeader("Connection", "keep-alive");
+  res.setHeader("X-Accel-Buffering", "no");
+  res.flushHeaders();
+  sessionBroadcaster2.registerClient(sessionId, cwd, res);
+});
+var sessions_default = router;
+
+// ../../apps/server/src/routes/commands.ts
+import { Router as Router2 } from "express";
+
+// ../../apps/server/src/services/command-registry.ts
+import fs2 from "fs/promises";
+import path4 from "path";
+import matter from "gray-matter";
+function parseFrontmatterFallback(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const val = line.slice(colonIdx + 1).trim();
+    if (key && val) result[key] = val;
+  }
+  return result;
+}
+var CommandRegistryService = class {
+  cache = null;
+  commandsDir;
+  constructor(vaultRoot2) {
+    this.commandsDir = path4.join(vaultRoot2, ".claude", "commands");
+  }
+  async getCommands(forceRefresh = false) {
+    if (this.cache && !forceRefresh) return this.cache;
+    const commands = [];
+    try {
+      const entries = await fs2.readdir(this.commandsDir, {
+        withFileTypes: true
+      });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const nsPath = path4.join(this.commandsDir, entry.name);
+        const files = await fs2.readdir(nsPath);
+        for (const file of files) {
+          if (!file.endsWith(".md")) continue;
+          const filePath = path4.join(nsPath, file);
+          try {
+            const content = await fs2.readFile(filePath, "utf-8");
+            let frontmatter;
+            try {
+              frontmatter = matter(content).data;
+            } catch {
+              frontmatter = parseFrontmatterFallback(content);
+            }
+            const commandName = file.replace(".md", "");
+            const allowedToolsRaw = frontmatter["allowed-tools"];
+            commands.push({
+              namespace: entry.name,
+              command: commandName,
+              fullCommand: `/${entry.name}:${commandName}`,
+              description: frontmatter.description || "",
+              argumentHint: frontmatter["argument-hint"],
+              allowedTools: typeof allowedToolsRaw === "string" ? allowedToolsRaw.split(",").map((t) => t.trim()) : allowedToolsRaw,
+              filePath: path4.relative(process.cwd(), filePath)
+            });
+          } catch (fileErr) {
+            console.warn(`[CommandRegistry] Skipping ${entry.name}/${file}: ${fileErr.message}`);
+          }
+        }
+      }
+    } catch (err) {
+      console.warn("[CommandRegistry] Could not read commands directory:", err.message);
+    }
+    commands.sort((a, b) => a.fullCommand.localeCompare(b.fullCommand));
+    this.cache = { commands, lastScanned: (/* @__PURE__ */ new Date()).toISOString() };
+    return this.cache;
+  }
+  invalidateCache() {
+    this.cache = null;
+  }
+};
+
+// ../../apps/server/src/routes/commands.ts
+import path5 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
+var defaultRoot = process.env.GATEWAY_CWD ?? path5.resolve(__dirname3, "../../../../");
+var registryCache = /* @__PURE__ */ new Map();
+function getRegistry(cwd) {
+  const root = cwd || defaultRoot;
+  let registry2 = registryCache.get(root);
+  if (!registry2) {
+    registry2 = new CommandRegistryService(root);
+    registryCache.set(root, registry2);
+  }
+  return registry2;
+}
+var router2 = Router2();
+router2.get("/", async (req, res) => {
+  const parsed = CommandsQuerySchema.safeParse(req.query);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid query", details: parsed.error.format() });
+  }
+  const refresh = parsed.data.refresh === "true";
+  const registry2 = getRegistry(parsed.data.cwd);
+  const commands = await registry2.getCommands(refresh);
+  res.json(commands);
+});
+var commands_default = router2;
+
+// ../../apps/server/src/routes/health.ts
+import { Router as Router3 } from "express";
+
+// ../../apps/server/src/services/tunnel-manager.ts
+var TunnelManager = class {
+  listener = null;
+  _status = {
+    enabled: false,
+    connected: false,
+    url: null,
+    port: null,
+    startedAt: null
+  };
+  get status() {
+    return { ...this._status };
+  }
+  async start(config) {
+    if (this.listener) throw new Error("Tunnel is already running");
+    const ngrok = await import("@ngrok/ngrok");
+    const forwardOpts = {
+      addr: config.port,
+      authtoken_from_env: true
+    };
+    if (config.authtoken) {
+      forwardOpts.authtoken = config.authtoken;
+      delete forwardOpts.authtoken_from_env;
+    }
+    if (config.basicAuth) forwardOpts.basic_auth = [config.basicAuth];
+    if (config.domain) forwardOpts.domain = config.domain;
+    this.listener = await ngrok.forward(forwardOpts);
+    const url = this.listener.url() ?? "";
+    this._status = {
+      enabled: true,
+      connected: true,
+      url,
+      port: config.port,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return url;
+  }
+  async stop() {
+    if (this.listener) {
+      await this.listener.close();
+      this.listener = null;
+    }
+    this._status = {
+      enabled: this._status.enabled,
+      connected: false,
+      url: null,
+      port: this._status.port,
+      startedAt: this._status.startedAt
+    };
+  }
+};
+var tunnelManager = new TunnelManager();
+
+// ../../apps/server/src/routes/health.ts
+var router3 = Router3();
+router3.get("/", (_req, res) => {
+  const response = {
+    status: "ok",
+    version: "1.0.0",
+    uptime: process.uptime()
+  };
+  const tunnelStatus = tunnelManager.status;
+  if (tunnelStatus.enabled) {
+    response.tunnel = {
+      connected: tunnelStatus.connected,
+      url: tunnelStatus.url,
+      port: tunnelStatus.port,
+      startedAt: tunnelStatus.startedAt
+    };
+  }
+  res.json(response);
+});
+var health_default = router3;
+
+// ../../apps/server/src/routes/directory.ts
+import { Router as Router4 } from "express";
+import fs3 from "fs/promises";
+import path6 from "path";
+import os2 from "os";
+var router4 = Router4();
+var HOME = os2.homedir();
+router4.get("/", async (req, res) => {
+  const parsed = BrowseDirectoryQuerySchema.safeParse(req.query);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid query", details: parsed.error.format() });
+  }
+  const { path: userPath, showHidden } = parsed.data;
+  const targetPath = userPath || HOME;
+  if (targetPath.includes("\0")) {
+    return res.status(400).json({ error: "Invalid path" });
+  }
+  let resolved;
+  try {
+    resolved = await fs3.realpath(targetPath);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT") return res.status(404).json({ error: "Directory not found" });
+    if (code === "EACCES") return res.status(403).json({ error: "Permission denied" });
+    throw err;
+  }
+  if (!resolved.startsWith(HOME)) {
+    return res.status(403).json({ error: "Access denied: path outside home directory" });
+  }
+  let dirents;
+  try {
+    dirents = await fs3.readdir(resolved, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (code === "EACCES") return res.status(403).json({ error: "Permission denied" });
+    if (code === "ENOTDIR") return res.status(400).json({ error: "Not a directory" });
+    throw err;
+  }
+  const entries = dirents.filter((d) => d.isDirectory()).filter((d) => showHidden || !d.name.startsWith(".")).map((d) => ({
+    name: d.name,
+    path: path6.join(resolved, d.name),
+    isDirectory: true
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  const parent = path6.dirname(resolved);
+  const hasParent = parent !== resolved && parent.startsWith(HOME);
+  res.json({
+    path: resolved,
+    entries,
+    parent: hasParent ? parent : null
+  });
+});
+router4.get("/default", (_req, res) => {
+  res.json({ path: process.cwd() });
+});
+var directory_default = router4;
+
+// ../../apps/server/src/routes/config.ts
+import { Router as Router5 } from "express";
+var router5 = Router5();
+router5.get("/", (_req, res) => {
+  let claudeCliPath = null;
+  try {
+    claudeCliPath = resolveClaudeCliPath() ?? null;
+  } catch {
+  }
+  const tunnel = tunnelManager.status;
+  res.json({
+    version: "1.0.0",
+    port: parseInt(process.env.GATEWAY_PORT || "6942", 10),
+    uptime: process.uptime(),
+    workingDirectory: process.cwd(),
+    nodeVersion: process.version,
+    claudeCliPath,
+    tunnel: {
+      enabled: tunnel.enabled,
+      connected: tunnel.connected,
+      url: tunnel.url,
+      authEnabled: !!process.env.TUNNEL_AUTH,
+      tokenConfigured: !!process.env.NGROK_AUTHTOKEN
+    }
+  });
+});
+var config_default = router5;
+
+// ../../apps/server/src/routes/files.ts
+import { Router as Router6 } from "express";
+
+// ../../apps/server/src/services/file-lister.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import fs4 from "fs/promises";
+import path7 from "path";
+var execFileAsync = promisify(execFile);
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  ".next",
+  "coverage",
+  "__pycache__",
+  ".cache"
+]);
+var MAX_FILES = 1e4;
+var CACHE_TTL = 5 * 60 * 1e3;
+var FileListService = class {
+  cache = /* @__PURE__ */ new Map();
+  async listFiles(cwd) {
+    const cached = this.cache.get(cwd);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+      return { files: cached.files, truncated: cached.files.length >= MAX_FILES, total: cached.files.length };
+    }
+    let files;
+    try {
+      files = await this.listViaGit(cwd);
+    } catch {
+      files = await this.listViaReaddir(cwd);
+    }
+    const truncated = files.length > MAX_FILES;
+    if (truncated) files = files.slice(0, MAX_FILES);
+    this.cache.set(cwd, { files, timestamp: Date.now() });
+    return { files, truncated, total: files.length };
+  }
+  async listViaGit(cwd) {
+    const { stdout } = await execFileAsync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+      cwd,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return stdout.split("\n").filter(Boolean);
+  }
+  async listViaReaddir(cwd, prefix = "", depth = 0) {
+    if (depth > 8) return [];
+    const results = [];
+    const entries = await fs4.readdir(path7.join(cwd, prefix), { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".") continue;
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        if (EXCLUDED_DIRS.has(entry.name)) continue;
+        results.push(...await this.listViaReaddir(cwd, rel, depth + 1));
+      } else {
+        results.push(rel);
+      }
+      if (results.length >= MAX_FILES) break;
+    }
+    return results;
+  }
+  invalidateCache(cwd) {
+    if (cwd) this.cache.delete(cwd);
+    else this.cache.clear();
+  }
+};
+var fileLister = new FileListService();
+
+// ../../apps/server/src/routes/files.ts
+var router6 = Router6();
+router6.get("/", async (req, res) => {
+  const parsed = FileListQuerySchema.safeParse(req.query);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid query", details: parsed.error.format() });
+  }
+  const result = await fileLister.listFiles(parsed.data.cwd);
+  res.json(result);
+});
+var files_default = router6;
+
+// ../../apps/server/src/routes/git.ts
+import { Router as Router7 } from "express";
+import { z as z2 } from "zod";
+
+// ../../apps/server/src/services/git-status.ts
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
+async function getGitStatus(cwd) {
+  try {
+    const { stdout } = await execFileAsync2("git", ["status", "--porcelain=v1", "--branch"], {
+      cwd,
+      timeout: 5e3
+    });
+    return parsePorcelainOutput(stdout);
+  } catch {
+    return { error: "not_git_repo" };
+  }
+}
+var CONFLICT_CODES = /* @__PURE__ */ new Set(["UU", "AA", "DD", "AU", "UA", "DU", "UD"]);
+var STAGED_CODES = /* @__PURE__ */ new Set(["M", "A", "D", "R", "C"]);
+function parsePorcelainOutput(stdout) {
+  const lines = stdout.split("\n").filter(Boolean);
+  let branch = "";
+  let tracking = null;
+  let ahead = 0;
+  let behind = 0;
+  let detached = false;
+  let modified = 0;
+  let staged = 0;
+  let untracked = 0;
+  let conflicted = 0;
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      const branchLine = line.slice(3);
+      if (branchLine.startsWith("HEAD (no branch)")) {
+        detached = true;
+        branch = "HEAD";
+        continue;
+      }
+      const bracketMatch = branchLine.match(/\[(.+)\]/);
+      if (bracketMatch) {
+        const info = bracketMatch[1];
+        const aheadMatch = info.match(/ahead (\d+)/);
+        const behindMatch = info.match(/behind (\d+)/);
+        if (aheadMatch) ahead = parseInt(aheadMatch[1], 10);
+        if (behindMatch) behind = parseInt(behindMatch[1], 10);
+      }
+      const branchPart = branchLine.replace(/\s*\[.*\]/, "");
+      const dotIndex = branchPart.indexOf("...");
+      if (dotIndex !== -1) {
+        branch = branchPart.slice(0, dotIndex);
+        tracking = branchPart.slice(dotIndex + 3);
+      } else {
+        branch = branchPart;
+      }
+      continue;
+    }
+    const x = line[0];
+    const y = line[1];
+    const code = `${x}${y}`;
+    if (code === "??") {
+      untracked++;
+    } else if (CONFLICT_CODES.has(code)) {
+      conflicted++;
+    } else {
+      if (STAGED_CODES.has(x)) staged++;
+      if (y === "M" || y === "D") modified++;
+    }
+  }
+  const clean = modified === 0 && staged === 0 && untracked === 0 && conflicted === 0;
+  return { branch, ahead, behind, modified, staged, untracked, conflicted, clean, detached, tracking };
+}
+
+// ../../apps/server/src/routes/git.ts
+var router7 = Router7();
+var GitStatusQuerySchema = z2.object({
+  dir: z2.string().optional()
+});
+router7.get("/status", async (req, res) => {
+  const parsed = GitStatusQuerySchema.safeParse(req.query);
+  if (!parsed.success) {
+    return res.status(400).json({ error: "Invalid query", details: parsed.error.format() });
+  }
+  const cwd = parsed.data.dir || process.cwd();
+  const result = await getGitStatus(cwd);
+  res.json(result);
+});
+var git_default = router7;
+
+// ../../apps/server/src/services/openapi-registry.ts
+import {
+  OpenAPIRegistry,
+  OpenApiGeneratorV31
+} from "@asteasolutions/zod-to-openapi";
+import { z as z3 } from "zod";
+var registry = new OpenAPIRegistry();
+registry.registerPath({
+  method: "get",
+  path: "/api/health",
+  tags: ["Health"],
+  summary: "Health check",
+  responses: {
+    200: {
+      description: "Server is healthy",
+      content: { "application/json": { schema: HealthResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "post",
+  path: "/api/sessions",
+  tags: ["Sessions"],
+  summary: "Create a new session",
+  request: {
+    body: {
+      content: { "application/json": { schema: CreateSessionRequestSchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "Created session",
+      content: { "application/json": { schema: SessionSchema } }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "get",
+  path: "/api/sessions",
+  tags: ["Sessions"],
+  summary: "List all sessions",
+  request: {
+    query: ListSessionsQuerySchema
+  },
+  responses: {
+    200: {
+      description: "Array of sessions",
+      content: {
+        "application/json": { schema: z3.array(SessionSchema) }
+      }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "get",
+  path: "/api/sessions/{id}",
+  tags: ["Sessions"],
+  summary: "Get session details",
+  request: {
+    params: z3.object({ id: z3.string().uuid() })
+  },
+  responses: {
+    200: {
+      description: "Session details",
+      content: { "application/json": { schema: SessionSchema } }
+    },
+    404: {
+      description: "Session not found",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "get",
+  path: "/api/sessions/{id}/messages",
+  tags: ["Sessions"],
+  summary: "Get message history",
+  request: {
+    params: z3.object({ id: z3.string().uuid() })
+  },
+  responses: {
+    200: {
+      description: "Message history",
+      content: {
+        "application/json": {
+          schema: z3.object({ messages: z3.array(HistoryMessageSchema) })
+        }
+      }
+    }
+  }
+});
+registry.registerPath({
+  method: "get",
+  path: "/api/sessions/{id}/tasks",
+  tags: ["Sessions"],
+  summary: "Get task state from session transcript",
+  request: {
+    params: z3.object({ id: z3.string().uuid() })
+  },
+  responses: {
+    200: {
+      description: "Task list",
+      content: {
+        "application/json": {
+          schema: z3.object({ tasks: z3.array(TaskItemSchema) })
+        }
+      }
+    },
+    404: {
+      description: "Session not found",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "patch",
+  path: "/api/sessions/{id}",
+  tags: ["Sessions"],
+  summary: "Update session settings",
+  request: {
+    params: z3.object({ id: z3.string().uuid() }),
+    body: {
+      content: { "application/json": { schema: UpdateSessionRequestSchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "Updated session",
+      content: { "application/json": { schema: SessionSchema } }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    },
+    404: {
+      description: "Session not found",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "post",
+  path: "/api/sessions/{id}/messages",
+  tags: ["Sessions"],
+  summary: "Send message (SSE stream response)",
+  description: 'Sends a message to the Claude agent and streams the response as Server-Sent Events. Event types: text_delta, tool_call_start, tool_call_delta, tool_call_end, tool_result, approval_required, question_prompt, error, done, session_status, task_update. Each SSE message has the format: `event: message\\ndata: {"type":"<type>","data":{...}}\\n\\n`',
+  request: {
+    params: z3.object({ id: z3.string().uuid() }),
+    body: {
+      content: { "application/json": { schema: SendMessageRequestSchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "SSE stream of StreamEvent objects",
+      content: {
+        "text/event-stream": {
+          schema: z3.string().openapi({ description: "Server-Sent Events stream" })
+        }
+      }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "post",
+  path: "/api/sessions/{id}/approve",
+  tags: ["Sessions"],
+  summary: "Approve pending tool call",
+  request: {
+    params: z3.object({ id: z3.string().uuid() }),
+    body: {
+      content: { "application/json": { schema: ApprovalRequestSchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "Approved",
+      content: {
+        "application/json": { schema: z3.object({ ok: z3.boolean() }) }
+      }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    },
+    404: {
+      description: "No pending approval",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "post",
+  path: "/api/sessions/{id}/deny",
+  tags: ["Sessions"],
+  summary: "Deny pending tool call",
+  request: {
+    params: z3.object({ id: z3.string().uuid() }),
+    body: {
+      content: { "application/json": { schema: ApprovalRequestSchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "Denied",
+      content: {
+        "application/json": { schema: z3.object({ ok: z3.boolean() }) }
+      }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    },
+    404: {
+      description: "No pending approval",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "post",
+  path: "/api/sessions/{id}/submit-answers",
+  tags: ["Sessions"],
+  summary: "Submit answers for AskUserQuestion",
+  request: {
+    params: z3.object({ id: z3.string().uuid() }),
+    body: {
+      content: { "application/json": { schema: SubmitAnswersRequestSchema } }
+    }
+  },
+  responses: {
+    200: {
+      description: "Answers submitted",
+      content: {
+        "application/json": { schema: z3.object({ ok: z3.boolean() }) }
+      }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    },
+    404: {
+      description: "No pending question",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "get",
+  path: "/api/directory",
+  tags: ["Directory"],
+  summary: "Browse directories",
+  description: "Browse directories on the server filesystem. Restricted to the home directory for security.",
+  request: {
+    query: BrowseDirectoryQuerySchema
+  },
+  responses: {
+    200: {
+      description: "Directory listing",
+      content: { "application/json": { schema: BrowseDirectoryResponseSchema } }
+    },
+    400: {
+      description: "Invalid path",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    },
+    403: {
+      description: "Access denied (path outside home directory)",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    },
+    404: {
+      description: "Directory not found",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+registry.registerPath({
+  method: "get",
+  path: "/api/directory/default",
+  tags: ["Directory"],
+  summary: "Get default working directory",
+  description: "Returns the server's default working directory (process.cwd()).",
+  responses: {
+    200: {
+      description: "Default directory path",
+      content: {
+        "application/json": {
+          schema: z3.object({ path: z3.string() })
+        }
+      }
+    }
+  }
+});
+registry.registerPath({
+  method: "get",
+  path: "/api/commands",
+  tags: ["Commands"],
+  summary: "List all slash commands",
+  request: {
+    query: CommandsQuerySchema
+  },
+  responses: {
+    200: {
+      description: "Command registry",
+      content: { "application/json": { schema: CommandRegistrySchema } }
+    },
+    400: {
+      description: "Validation error",
+      content: { "application/json": { schema: ErrorResponseSchema } }
+    }
+  }
+});
+function generateOpenAPISpec() {
+  const generator = new OpenApiGeneratorV31(registry.definitions);
+  return generator.generateDocument({
+    openapi: "3.1.0",
+    info: {
+      title: "DorkOS API",
+      version: "0.1.0",
+      description: "REST/SSE API for Claude Code sessions, built with the Claude Agent SDK."
+    },
+    servers: [{ url: "http://localhost:6942" }]
+  });
+}
+
+// ../../apps/server/src/middleware/error-handler.ts
+function errorHandler(err, _req, res, _next) {
+  console.error("[Gateway Error]", err.message, err.stack);
+  res.status(500).json({
+    error: err.message || "Internal Server Error",
+    code: "INTERNAL_ERROR"
+  });
+}
+
+// ../../apps/server/src/app.ts
+var __dirname4 = path8.dirname(fileURLToPath4(import.meta.url));
+function createApp() {
+  const app = express();
+  app.use(cors());
+  app.use(express.json());
+  app.use("/api/sessions", sessions_default);
+  app.use("/api/commands", commands_default);
+  app.use("/api/health", health_default);
+  app.use("/api/directory", directory_default);
+  app.use("/api/config", config_default);
+  app.use("/api/files", files_default);
+  app.use("/api/git", git_default);
+  const spec = generateOpenAPISpec();
+  app.get("/api/openapi.json", (_req, res) => res.json(spec));
+  app.use("/api/docs", apiReference({ content: spec }));
+  app.use(errorHandler);
+  if (process.env.NODE_ENV === "production") {
+    const distPath = process.env.CLIENT_DIST_PATH ?? path8.join(__dirname4, "../../client/dist");
+    app.use(express.static(distPath));
+    app.get("*", (_req, res) => {
+      res.sendFile(path8.join(distPath, "index.html"));
+    });
+  }
+  return app;
+}
+
+// ../../node_modules/chokidar/esm/index.js
+import { stat as statcb } from "fs";
+import { stat as stat3, readdir as readdir2 } from "fs/promises";
+import { EventEmitter } from "events";
+import * as sysPath2 from "path";
+
+// ../../node_modules/readdirp/esm/index.js
+import { stat, lstat, readdir, realpath } from "node:fs/promises";
+import { Readable } from "node:stream";
+import { resolve as presolve, relative as prelative, join as pjoin, sep as psep } from "node:path";
+var EntryTypes = {
+  FILE_TYPE: "files",
+  DIR_TYPE: "directories",
+  FILE_DIR_TYPE: "files_directories",
+  EVERYTHING_TYPE: "all"
+};
+var defaultOptions = {
+  root: ".",
+  fileFilter: (_entryInfo) => true,
+  directoryFilter: (_entryInfo) => true,
+  type: EntryTypes.FILE_TYPE,
+  lstat: false,
+  depth: 2147483648,
+  alwaysStat: false,
+  highWaterMark: 4096
+};
+Object.freeze(defaultOptions);
+var RECURSIVE_ERROR_CODE = "READDIRP_RECURSIVE_ERROR";
+var NORMAL_FLOW_ERRORS = /* @__PURE__ */ new Set(["ENOENT", "EPERM", "EACCES", "ELOOP", RECURSIVE_ERROR_CODE]);
+var ALL_TYPES = [
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+];
+var DIR_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.DIR_TYPE,
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE
+]);
+var FILE_TYPES = /* @__PURE__ */ new Set([
+  EntryTypes.EVERYTHING_TYPE,
+  EntryTypes.FILE_DIR_TYPE,
+  EntryTypes.FILE_TYPE
+]);
+var isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+var wantBigintFsStats = process.platform === "win32";
+var emptyFn = (_entryInfo) => true;
+var normalizeFilter = (filter) => {
+  if (filter === void 0)
+    return emptyFn;
+  if (typeof filter === "function")
+    return filter;
+  if (typeof filter === "string") {
+    const fl = filter.trim();
+    return (entry) => entry.basename === fl;
+  }
+  if (Array.isArray(filter)) {
+    const trItems = filter.map((item) => item.trim());
+    return (entry) => trItems.some((f) => entry.basename === f);
+  }
+  return emptyFn;
+};
+var ReaddirpStream = class extends Readable {
+  constructor(options = {}) {
+    super({
+      objectMode: true,
+      autoDestroy: true,
+      highWaterMark: options.highWaterMark
+    });
+    const opts = { ...defaultOptions, ...options };
+    const { root, type } = opts;
+    this._fileFilter = normalizeFilter(opts.fileFilter);
+    this._directoryFilter = normalizeFilter(opts.directoryFilter);
+    const statMethod = opts.lstat ? lstat : stat;
+    if (wantBigintFsStats) {
+      this._stat = (path10) => statMethod(path10, { bigint: true });
+    } else {
+      this._stat = statMethod;
+    }
+    this._maxDepth = opts.depth ?? defaultOptions.depth;
+    this._wantsDir = type ? DIR_TYPES.has(type) : false;
+    this._wantsFile = type ? FILE_TYPES.has(type) : false;
+    this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
+    this._root = presolve(root);
+    this._isDirent = !opts.alwaysStat;
+    this._statsProp = this._isDirent ? "dirent" : "stats";
+    this._rdOptions = { encoding: "utf8", withFileTypes: this._isDirent };
+    this.parents = [this._exploreDir(root, 1)];
+    this.reading = false;
+    this.parent = void 0;
+  }
+  async _read(batch) {
+    if (this.reading)
+      return;
+    this.reading = true;
+    try {
+      while (!this.destroyed && batch > 0) {
+        const par = this.parent;
+        const fil = par && par.files;
+        if (fil && fil.length > 0) {
+          const { path: path10, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path10));
+          const awaited = await Promise.all(slice);
+          for (const entry of awaited) {
+            if (!entry)
+              continue;
+            if (this.destroyed)
+              return;
+            const entryType = await this._getEntryType(entry);
+            if (entryType === "directory" && this._directoryFilter(entry)) {
+              if (depth <= this._maxDepth) {
+                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+              }
+              if (this._wantsDir) {
+                this.push(entry);
+                batch--;
+              }
+            } else if ((entryType === "file" || this._includeAsFile(entry)) && this._fileFilter(entry)) {
+              if (this._wantsFile) {
+                this.push(entry);
+                batch--;
+              }
+            }
+          }
+        } else {
+          const parent = this.parents.pop();
+          if (!parent) {
+            this.push(null);
+            break;
+          }
+          this.parent = await parent;
+          if (this.destroyed)
+            return;
+        }
+      }
+    } catch (error) {
+      this.destroy(error);
+    } finally {
+      this.reading = false;
+    }
+  }
+  async _exploreDir(path10, depth) {
+    let files;
+    try {
+      files = await readdir(path10, this._rdOptions);
+    } catch (error) {
+      this._onError(error);
+    }
+    return { files, depth, path: path10 };
+  }
+  async _formatEntry(dirent, path10) {
+    let entry;
+    const basename3 = this._isDirent ? dirent.name : dirent;
+    try {
+      const fullPath = presolve(pjoin(path10, basename3));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename3 };
+      entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+    } catch (err) {
+      this._onError(err);
+      return;
+    }
+    return entry;
+  }
+  _onError(err) {
+    if (isNormalFlowError(err) && !this.destroyed) {
+      this.emit("warn", err);
+    } else {
+      this.destroy(err);
+    }
+  }
+  async _getEntryType(entry) {
+    if (!entry && this._statsProp in entry) {
+      return "";
+    }
+    const stats = entry[this._statsProp];
+    if (stats.isFile())
+      return "file";
+    if (stats.isDirectory())
+      return "directory";
+    if (stats && stats.isSymbolicLink()) {
+      const full = entry.fullPath;
+      try {
+        const entryRealPath = await realpath(full);
+        const entryRealPathStats = await lstat(entryRealPath);
+        if (entryRealPathStats.isFile()) {
+          return "file";
+        }
+        if (entryRealPathStats.isDirectory()) {
+          const len = entryRealPath.length;
+          if (full.startsWith(entryRealPath) && full.substr(len, 1) === psep) {
+            const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+            recursiveError.code = RECURSIVE_ERROR_CODE;
+            return this._onError(recursiveError);
+          }
+          return "directory";
+        }
+      } catch (error) {
+        this._onError(error);
+        return "";
+      }
+    }
+  }
+  _includeAsFile(entry) {
+    const stats = entry && entry[this._statsProp];
+    return stats && this._wantsEverything && !stats.isDirectory();
+  }
+};
+function readdirp(root, options = {}) {
+  let type = options.entryType || options.type;
+  if (type === "both")
+    type = EntryTypes.FILE_DIR_TYPE;
+  if (type)
+    options.type = type;
+  if (!root) {
+    throw new Error("readdirp: root argument is required. Usage: readdirp(root, options)");
+  } else if (typeof root !== "string") {
+    throw new TypeError("readdirp: root argument must be a string. Usage: readdirp(root, options)");
+  } else if (type && !ALL_TYPES.includes(type)) {
+    throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(", ")}`);
+  }
+  options.root = root;
+  return new ReaddirpStream(options);
+}
+
+// ../../node_modules/chokidar/esm/handler.js
+import { watchFile, unwatchFile, watch as fs_watch } from "fs";
+import { open, stat as stat2, lstat as lstat2, realpath as fsrealpath } from "fs/promises";
+import * as sysPath from "path";
+import { type as osType } from "os";
+var STR_DATA = "data";
+var STR_END = "end";
+var STR_CLOSE = "close";
+var EMPTY_FN = () => {
+};
+var pl = process.platform;
+var isWindows = pl === "win32";
+var isMacos = pl === "darwin";
+var isLinux = pl === "linux";
+var isFreeBSD = pl === "freebsd";
+var isIBMi = osType() === "OS400";
+var EVENTS = {
+  ALL: "all",
+  READY: "ready",
+  ADD: "add",
+  CHANGE: "change",
+  ADD_DIR: "addDir",
+  UNLINK: "unlink",
+  UNLINK_DIR: "unlinkDir",
+  RAW: "raw",
+  ERROR: "error"
+};
+var EV = EVENTS;
+var THROTTLE_MODE_WATCH = "watch";
+var statMethods = { lstat: lstat2, stat: stat2 };
+var KEY_LISTENERS = "listeners";
+var KEY_ERR = "errHandlers";
+var KEY_RAW = "rawEmitters";
+var HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
+var binaryExtensions = /* @__PURE__ */ new Set([
+  "3dm",
+  "3ds",
+  "3g2",
+  "3gp",
+  "7z",
+  "a",
+  "aac",
+  "adp",
+  "afdesign",
+  "afphoto",
+  "afpub",
+  "ai",
+  "aif",
+  "aiff",
+  "alz",
+  "ape",
+  "apk",
+  "appimage",
+  "ar",
+  "arj",
+  "asf",
+  "au",
+  "avi",
+  "bak",
+  "baml",
+  "bh",
+  "bin",
+  "bk",
+  "bmp",
+  "btif",
+  "bz2",
+  "bzip2",
+  "cab",
+  "caf",
+  "cgm",
+  "class",
+  "cmx",
+  "cpio",
+  "cr2",
+  "cur",
+  "dat",
+  "dcm",
+  "deb",
+  "dex",
+  "djvu",
+  "dll",
+  "dmg",
+  "dng",
+  "doc",
+  "docm",
+  "docx",
+  "dot",
+  "dotm",
+  "dra",
+  "DS_Store",
+  "dsk",
+  "dts",
+  "dtshd",
+  "dvb",
+  "dwg",
+  "dxf",
+  "ecelp4800",
+  "ecelp7470",
+  "ecelp9600",
+  "egg",
+  "eol",
+  "eot",
+  "epub",
+  "exe",
+  "f4v",
+  "fbs",
+  "fh",
+  "fla",
+  "flac",
+  "flatpak",
+  "fli",
+  "flv",
+  "fpx",
+  "fst",
+  "fvt",
+  "g3",
+  "gh",
+  "gif",
+  "graffle",
+  "gz",
+  "gzip",
+  "h261",
+  "h263",
+  "h264",
+  "icns",
+  "ico",
+  "ief",
+  "img",
+  "ipa",
+  "iso",
+  "jar",
+  "jpeg",
+  "jpg",
+  "jpgv",
+  "jpm",
+  "jxr",
+  "key",
+  "ktx",
+  "lha",
+  "lib",
+  "lvp",
+  "lz",
+  "lzh",
+  "lzma",
+  "lzo",
+  "m3u",
+  "m4a",
+  "m4v",
+  "mar",
+  "mdi",
+  "mht",
+  "mid",
+  "midi",
+  "mj2",
+  "mka",
+  "mkv",
+  "mmr",
+  "mng",
+  "mobi",
+  "mov",
+  "movie",
+  "mp3",
+  "mp4",
+  "mp4a",
+  "mpeg",
+  "mpg",
+  "mpga",
+  "mxu",
+  "nef",
+  "npx",
+  "numbers",
+  "nupkg",
+  "o",
+  "odp",
+  "ods",
+  "odt",
+  "oga",
+  "ogg",
+  "ogv",
+  "otf",
+  "ott",
+  "pages",
+  "pbm",
+  "pcx",
+  "pdb",
+  "pdf",
+  "pea",
+  "pgm",
+  "pic",
+  "png",
+  "pnm",
+  "pot",
+  "potm",
+  "potx",
+  "ppa",
+  "ppam",
+  "ppm",
+  "pps",
+  "ppsm",
+  "ppsx",
+  "ppt",
+  "pptm",
+  "pptx",
+  "psd",
+  "pya",
+  "pyc",
+  "pyo",
+  "pyv",
+  "qt",
+  "rar",
+  "ras",
+  "raw",
+  "resources",
+  "rgb",
+  "rip",
+  "rlc",
+  "rmf",
+  "rmvb",
+  "rpm",
+  "rtf",
+  "rz",
+  "s3m",
+  "s7z",
+  "scpt",
+  "sgi",
+  "shar",
+  "snap",
+  "sil",
+  "sketch",
+  "slk",
+  "smv",
+  "snk",
+  "so",
+  "stl",
+  "suo",
+  "sub",
+  "swf",
+  "tar",
+  "tbz",
+  "tbz2",
+  "tga",
+  "tgz",
+  "thmx",
+  "tif",
+  "tiff",
+  "tlz",
+  "ttc",
+  "ttf",
+  "txz",
+  "udf",
+  "uvh",
+  "uvi",
+  "uvm",
+  "uvp",
+  "uvs",
+  "uvu",
+  "viv",
+  "vob",
+  "war",
+  "wav",
+  "wax",
+  "wbmp",
+  "wdp",
+  "weba",
+  "webm",
+  "webp",
+  "whl",
+  "wim",
+  "wm",
+  "wma",
+  "wmv",
+  "wmx",
+  "woff",
+  "woff2",
+  "wrm",
+  "wvx",
+  "xbm",
+  "xif",
+  "xla",
+  "xlam",
+  "xls",
+  "xlsb",
+  "xlsm",
+  "xlsx",
+  "xlt",
+  "xltm",
+  "xltx",
+  "xm",
+  "xmind",
+  "xpi",
+  "xpm",
+  "xwd",
+  "xz",
+  "z",
+  "zip",
+  "zipx"
+]);
+var isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+var foreach = (val, fn) => {
+  if (val instanceof Set) {
+    val.forEach(fn);
+  } else {
+    fn(val);
+  }
+};
+var addAndConvert = (main, prop, item) => {
+  let container = main[prop];
+  if (!(container instanceof Set)) {
+    main[prop] = container = /* @__PURE__ */ new Set([container]);
+  }
+  container.add(item);
+};
+var clearItem = (cont) => (key) => {
+  const set = cont[key];
+  if (set instanceof Set) {
+    set.clear();
+  } else {
+    delete cont[key];
+  }
+};
+var delFromSet = (main, prop, item) => {
+  const container = main[prop];
+  if (container instanceof Set) {
+    container.delete(item);
+  } else if (container === item) {
+    delete main[prop];
+  }
+};
+var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
+var FsWatchInstances = /* @__PURE__ */ new Map();
+function createFsWatchInstance(path10, options, listener, errHandler, emitRaw) {
+  const handleEvent = (rawEvent, evPath) => {
+    listener(path10);
+    emitRaw(rawEvent, evPath, { watchedPath: path10 });
+    if (evPath && path10 !== evPath) {
+      fsWatchBroadcast(sysPath.resolve(path10, evPath), KEY_LISTENERS, sysPath.join(path10, evPath));
+    }
+  };
+  try {
+    return fs_watch(path10, {
+      persistent: options.persistent
+    }, handleEvent);
+  } catch (error) {
+    errHandler(error);
+    return void 0;
+  }
+}
+var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
+  const cont = FsWatchInstances.get(fullPath);
+  if (!cont)
+    return;
+  foreach(cont[listenerType], (listener) => {
+    listener(val1, val2, val3);
+  });
+};
+var setFsWatchListener = (path10, fullPath, options, handlers) => {
+  const { listener, errHandler, rawEmitter } = handlers;
+  let cont = FsWatchInstances.get(fullPath);
+  let watcher;
+  if (!options.persistent) {
+    watcher = createFsWatchInstance(path10, options, listener, errHandler, rawEmitter);
+    if (!watcher)
+      return;
+    return watcher.close.bind(watcher);
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_ERR, errHandler);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    watcher = createFsWatchInstance(
+      path10,
+      options,
+      fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
+      errHandler,
+      // no need to use broadcast here
+      fsWatchBroadcast.bind(null, fullPath, KEY_RAW)
+    );
+    if (!watcher)
+      return;
+    watcher.on(EV.ERROR, async (error) => {
+      const broadcastErr = fsWatchBroadcast.bind(null, fullPath, KEY_ERR);
+      if (cont)
+        cont.watcherUnusable = true;
+      if (isWindows && error.code === "EPERM") {
+        try {
+          const fd = await open(path10, "r");
+          await fd.close();
+          broadcastErr(error);
+        } catch (err) {
+        }
+      } else {
+        broadcastErr(error);
+      }
+    });
+    cont = {
+      listeners: listener,
+      errHandlers: errHandler,
+      rawEmitters: rawEmitter,
+      watcher
+    };
+    FsWatchInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_ERR, errHandler);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      cont.watcher.close();
+      FsWatchInstances.delete(fullPath);
+      HANDLER_KEYS.forEach(clearItem(cont));
+      cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var FsWatchFileInstances = /* @__PURE__ */ new Map();
+var setFsWatchFileListener = (path10, fullPath, options, handlers) => {
+  const { listener, rawEmitter } = handlers;
+  let cont = FsWatchFileInstances.get(fullPath);
+  const copts = cont && cont.options;
+  if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
+    unwatchFile(fullPath);
+    cont = void 0;
+  }
+  if (cont) {
+    addAndConvert(cont, KEY_LISTENERS, listener);
+    addAndConvert(cont, KEY_RAW, rawEmitter);
+  } else {
+    cont = {
+      listeners: listener,
+      rawEmitters: rawEmitter,
+      options,
+      watcher: watchFile(fullPath, options, (curr, prev) => {
+        foreach(cont.rawEmitters, (rawEmitter2) => {
+          rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
+        });
+        const currmtime = curr.mtimeMs;
+        if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
+          foreach(cont.listeners, (listener2) => listener2(path10, curr));
+        }
+      })
+    };
+    FsWatchFileInstances.set(fullPath, cont);
+  }
+  return () => {
+    delFromSet(cont, KEY_LISTENERS, listener);
+    delFromSet(cont, KEY_RAW, rawEmitter);
+    if (isEmptySet(cont.listeners)) {
+      FsWatchFileInstances.delete(fullPath);
+      unwatchFile(fullPath);
+      cont.options = cont.watcher = void 0;
+      Object.freeze(cont);
+    }
+  };
+};
+var NodeFsHandler = class {
+  constructor(fsW) {
+    this.fsw = fsW;
+    this._boundHandleError = (error) => fsW._handleError(error);
+  }
+  /**
+   * Watch file for changes with fs_watchFile or fs_watch.
+   * @param path to file or dir
+   * @param listener on fs change
+   * @returns closer for the watcher instance
+   */
+  _watchWithNodeFs(path10, listener) {
+    const opts = this.fsw.options;
+    const directory = sysPath.dirname(path10);
+    const basename3 = sysPath.basename(path10);
+    const parent = this.fsw._getWatchedDir(directory);
+    parent.add(basename3);
+    const absolutePath = sysPath.resolve(path10);
+    const options = {
+      persistent: opts.persistent
+    };
+    if (!listener)
+      listener = EMPTY_FN;
+    let closer;
+    if (opts.usePolling) {
+      const enableBin = opts.interval !== opts.binaryInterval;
+      options.interval = enableBin && isBinaryPath(basename3) ? opts.binaryInterval : opts.interval;
+      closer = setFsWatchFileListener(path10, absolutePath, options, {
+        listener,
+        rawEmitter: this.fsw._emitRaw
+      });
+    } else {
+      closer = setFsWatchListener(path10, absolutePath, options, {
+        listener,
+        errHandler: this._boundHandleError,
+        rawEmitter: this.fsw._emitRaw
+      });
+    }
+    return closer;
+  }
+  /**
+   * Watch a file and emit add event if warranted.
+   * @returns closer for the watcher instance
+   */
+  _handleFile(file, stats, initialAdd) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const dirname3 = sysPath.dirname(file);
+    const basename3 = sysPath.basename(file);
+    const parent = this.fsw._getWatchedDir(dirname3);
+    let prevStats = stats;
+    if (parent.has(basename3))
+      return;
+    const listener = async (path10, newStats) => {
+      if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
+        return;
+      if (!newStats || newStats.mtimeMs === 0) {
+        try {
+          const newStats2 = await stat2(file);
+          if (this.fsw.closed)
+            return;
+          const at = newStats2.atimeMs;
+          const mt = newStats2.mtimeMs;
+          if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+            this.fsw._emit(EV.CHANGE, file, newStats2);
+          }
+          if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
+            this.fsw._closeFile(path10);
+            prevStats = newStats2;
+            const closer2 = this._watchWithNodeFs(file, listener);
+            if (closer2)
+              this.fsw._addPathCloser(path10, closer2);
+          } else {
+            prevStats = newStats2;
+          }
+        } catch (error) {
+          this.fsw._remove(dirname3, basename3);
+        }
+      } else if (parent.has(basename3)) {
+        const at = newStats.atimeMs;
+        const mt = newStats.mtimeMs;
+        if (!at || at <= mt || mt !== prevStats.mtimeMs) {
+          this.fsw._emit(EV.CHANGE, file, newStats);
+        }
+        prevStats = newStats;
+      }
+    };
+    const closer = this._watchWithNodeFs(file, listener);
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && this.fsw._isntIgnored(file)) {
+      if (!this.fsw._throttle(EV.ADD, file, 0))
+        return;
+      this.fsw._emit(EV.ADD, file, stats);
+    }
+    return closer;
+  }
+  /**
+   * Handle symlinks encountered while reading a dir.
+   * @param entry returned by readdirp
+   * @param directory path of dir being read
+   * @param path of this item
+   * @param item basename of this item
+   * @returns true if no more processing is needed for this entry.
+   */
+  async _handleSymlink(entry, directory, path10, item) {
+    if (this.fsw.closed) {
+      return;
+    }
+    const full = entry.fullPath;
+    const dir = this.fsw._getWatchedDir(directory);
+    if (!this.fsw.options.followSymlinks) {
+      this.fsw._incrReadyCount();
+      let linkPath;
+      try {
+        linkPath = await fsrealpath(path10);
+      } catch (e) {
+        this.fsw._emitReady();
+        return true;
+      }
+      if (this.fsw.closed)
+        return;
+      if (dir.has(item)) {
+        if (this.fsw._symlinkPaths.get(full) !== linkPath) {
+          this.fsw._symlinkPaths.set(full, linkPath);
+          this.fsw._emit(EV.CHANGE, path10, entry.stats);
+        }
+      } else {
+        dir.add(item);
+        this.fsw._symlinkPaths.set(full, linkPath);
+        this.fsw._emit(EV.ADD, path10, entry.stats);
+      }
+      this.fsw._emitReady();
+      return true;
+    }
+    if (this.fsw._symlinkPaths.has(full)) {
+      return true;
+    }
+    this.fsw._symlinkPaths.set(full, true);
+  }
+  _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
+    directory = sysPath.join(directory, "");
+    throttler = this.fsw._throttle("readdir", directory, 1e3);
+    if (!throttler)
+      return;
+    const previous = this.fsw._getWatchedDir(wh.path);
+    const current = /* @__PURE__ */ new Set();
+    let stream = this.fsw._readdirp(directory, {
+      fileFilter: (entry) => wh.filterPath(entry),
+      directoryFilter: (entry) => wh.filterDir(entry)
+    });
+    if (!stream)
+      return;
+    stream.on(STR_DATA, async (entry) => {
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      const item = entry.path;
+      let path10 = sysPath.join(directory, item);
+      current.add(item);
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path10, item)) {
+        return;
+      }
+      if (this.fsw.closed) {
+        stream = void 0;
+        return;
+      }
+      if (item === target || !target && !previous.has(item)) {
+        this.fsw._incrReadyCount();
+        path10 = sysPath.join(dir, sysPath.relative(dir, path10));
+        this._addToNodeFs(path10, initialAdd, wh, depth + 1);
+      }
+    }).on(EV.ERROR, this._boundHandleError);
+    return new Promise((resolve3, reject) => {
+      if (!stream)
+        return reject();
+      stream.once(STR_END, () => {
+        if (this.fsw.closed) {
+          stream = void 0;
+          return;
+        }
+        const wasThrottled = throttler ? throttler.clear() : false;
+        resolve3(void 0);
+        previous.getChildren().filter((item) => {
+          return item !== directory && !current.has(item);
+        }).forEach((item) => {
+          this.fsw._remove(directory, item);
+        });
+        stream = void 0;
+        if (wasThrottled)
+          this._handleRead(directory, false, wh, target, dir, depth, throttler);
+      });
+    });
+  }
+  /**
+   * Read directory to add / remove files from `@watched` list and re-read it on change.
+   * @param dir fs path
+   * @param stats
+   * @param initialAdd
+   * @param depth relative to user-supplied path
+   * @param target child path targeted for watch
+   * @param wh Common watch helpers for this path
+   * @param realpath
+   * @returns closer for the watcher instance.
+   */
+  async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath2) {
+    const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
+    const tracked = parentDir.has(sysPath.basename(dir));
+    if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
+      this.fsw._emit(EV.ADD_DIR, dir, stats);
+    }
+    parentDir.add(sysPath.basename(dir));
+    this.fsw._getWatchedDir(dir);
+    let throttler;
+    let closer;
+    const oDepth = this.fsw.options.depth;
+    if ((oDepth == null || depth <= oDepth) && !this.fsw._symlinkPaths.has(realpath2)) {
+      if (!target) {
+        await this._handleRead(dir, initialAdd, wh, target, dir, depth, throttler);
+        if (this.fsw.closed)
+          return;
+      }
+      closer = this._watchWithNodeFs(dir, (dirPath, stats2) => {
+        if (stats2 && stats2.mtimeMs === 0)
+          return;
+        this._handleRead(dirPath, false, wh, target, dir, depth, throttler);
+      });
+    }
+    return closer;
+  }
+  /**
+   * Handle added file, directory, or glob pattern.
+   * Delegates call to _handleFile / _handleDir after checks.
+   * @param path to file or ir
+   * @param initialAdd was the file added at watch instantiation?
+   * @param priorWh depth relative to user-supplied path
+   * @param depth Child path actually targeted for watch
+   * @param target Child path actually targeted for watch
+   */
+  async _addToNodeFs(path10, initialAdd, priorWh, depth, target) {
+    const ready = this.fsw._emitReady;
+    if (this.fsw._isIgnored(path10) || this.fsw.closed) {
+      ready();
+      return false;
+    }
+    const wh = this.fsw._getWatchHelpers(path10);
+    if (priorWh) {
+      wh.filterPath = (entry) => priorWh.filterPath(entry);
+      wh.filterDir = (entry) => priorWh.filterDir(entry);
+    }
+    try {
+      const stats = await statMethods[wh.statMethod](wh.watchPath);
+      if (this.fsw.closed)
+        return;
+      if (this.fsw._isIgnored(wh.watchPath, stats)) {
+        ready();
+        return false;
+      }
+      const follow = this.fsw.options.followSymlinks;
+      let closer;
+      if (stats.isDirectory()) {
+        const absPath = sysPath.resolve(path10);
+        const targetPath = follow ? await fsrealpath(path10) : path10;
+        if (this.fsw.closed)
+          return;
+        closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (absPath !== targetPath && targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(absPath, targetPath);
+        }
+      } else if (stats.isSymbolicLink()) {
+        const targetPath = follow ? await fsrealpath(path10) : path10;
+        if (this.fsw.closed)
+          return;
+        const parent = sysPath.dirname(wh.watchPath);
+        this.fsw._getWatchedDir(parent).add(wh.watchPath);
+        this.fsw._emit(EV.ADD, wh.watchPath, stats);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path10, wh, targetPath);
+        if (this.fsw.closed)
+          return;
+        if (targetPath !== void 0) {
+          this.fsw._symlinkPaths.set(sysPath.resolve(path10), targetPath);
+        }
+      } else {
+        closer = this._handleFile(wh.watchPath, stats, initialAdd);
+      }
+      ready();
+      if (closer)
+        this.fsw._addPathCloser(path10, closer);
+      return false;
+    } catch (error) {
+      if (this.fsw._handleError(error)) {
+        ready();
+        return path10;
+      }
+    }
+  }
+};
+
+// ../../node_modules/chokidar/esm/index.js
+var SLASH = "/";
+var SLASH_SLASH = "//";
+var ONE_DOT = ".";
+var TWO_DOTS = "..";
+var STRING_TYPE = "string";
+var BACK_SLASH_RE = /\\/g;
+var DOUBLE_SLASH_RE = /\/\//;
+var DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
+var REPLACER_RE = /^\.[/\\]/;
+function arrify(item) {
+  return Array.isArray(item) ? item : [item];
+}
+var isMatcherObject = (matcher) => typeof matcher === "object" && matcher !== null && !(matcher instanceof RegExp);
+function createPattern(matcher) {
+  if (typeof matcher === "function")
+    return matcher;
+  if (typeof matcher === "string")
+    return (string) => matcher === string;
+  if (matcher instanceof RegExp)
+    return (string) => matcher.test(string);
+  if (typeof matcher === "object" && matcher !== null) {
+    return (string) => {
+      if (matcher.path === string)
+        return true;
+      if (matcher.recursive) {
+        const relative3 = sysPath2.relative(matcher.path, string);
+        if (!relative3) {
+          return false;
+        }
+        return !relative3.startsWith("..") && !sysPath2.isAbsolute(relative3);
+      }
+      return false;
+    };
+  }
+  return () => false;
+}
+function normalizePath(path10) {
+  if (typeof path10 !== "string")
+    throw new Error("string expected");
+  path10 = sysPath2.normalize(path10);
+  path10 = path10.replace(/\\/g, "/");
+  let prepend = false;
+  if (path10.startsWith("//"))
+    prepend = true;
+  const DOUBLE_SLASH_RE2 = /\/\//;
+  while (path10.match(DOUBLE_SLASH_RE2))
+    path10 = path10.replace(DOUBLE_SLASH_RE2, "/");
+  if (prepend)
+    path10 = "/" + path10;
+  return path10;
+}
+function matchPatterns(patterns, testString, stats) {
+  const path10 = normalizePath(testString);
+  for (let index = 0; index < patterns.length; index++) {
+    const pattern = patterns[index];
+    if (pattern(path10, stats)) {
+      return true;
+    }
+  }
+  return false;
+}
+function anymatch(matchers, testString) {
+  if (matchers == null) {
+    throw new TypeError("anymatch: specify first argument");
+  }
+  const matchersArray = arrify(matchers);
+  const patterns = matchersArray.map((matcher) => createPattern(matcher));
+  if (testString == null) {
+    return (testString2, stats) => {
+      return matchPatterns(patterns, testString2, stats);
+    };
+  }
+  return matchPatterns(patterns, testString);
+}
+var unifyPaths = (paths_) => {
+  const paths = arrify(paths_).flat();
+  if (!paths.every((p) => typeof p === STRING_TYPE)) {
+    throw new TypeError(`Non-string provided as watch path: ${paths}`);
+  }
+  return paths.map(normalizePathToUnix);
+};
+var toUnix = (string) => {
+  let str = string.replace(BACK_SLASH_RE, SLASH);
+  let prepend = false;
+  if (str.startsWith(SLASH_SLASH)) {
+    prepend = true;
+  }
+  while (str.match(DOUBLE_SLASH_RE)) {
+    str = str.replace(DOUBLE_SLASH_RE, SLASH);
+  }
+  if (prepend) {
+    str = SLASH + str;
+  }
+  return str;
+};
+var normalizePathToUnix = (path10) => toUnix(sysPath2.normalize(toUnix(path10)));
+var normalizeIgnored = (cwd = "") => (path10) => {
+  if (typeof path10 === "string") {
+    return normalizePathToUnix(sysPath2.isAbsolute(path10) ? path10 : sysPath2.join(cwd, path10));
+  } else {
+    return path10;
+  }
+};
+var getAbsolutePath = (path10, cwd) => {
+  if (sysPath2.isAbsolute(path10)) {
+    return path10;
+  }
+  return sysPath2.join(cwd, path10);
+};
+var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
+var DirEntry = class {
+  constructor(dir, removeWatcher) {
+    this.path = dir;
+    this._removeWatcher = removeWatcher;
+    this.items = /* @__PURE__ */ new Set();
+  }
+  add(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    if (item !== ONE_DOT && item !== TWO_DOTS)
+      items.add(item);
+  }
+  async remove(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    items.delete(item);
+    if (items.size > 0)
+      return;
+    const dir = this.path;
+    try {
+      await readdir2(dir);
+    } catch (err) {
+      if (this._removeWatcher) {
+        this._removeWatcher(sysPath2.dirname(dir), sysPath2.basename(dir));
+      }
+    }
+  }
+  has(item) {
+    const { items } = this;
+    if (!items)
+      return;
+    return items.has(item);
+  }
+  getChildren() {
+    const { items } = this;
+    if (!items)
+      return [];
+    return [...items.values()];
+  }
+  dispose() {
+    this.items.clear();
+    this.path = "";
+    this._removeWatcher = EMPTY_FN;
+    this.items = EMPTY_SET;
+    Object.freeze(this);
+  }
+};
+var STAT_METHOD_F = "stat";
+var STAT_METHOD_L = "lstat";
+var WatchHelper = class {
+  constructor(path10, follow, fsw) {
+    this.fsw = fsw;
+    const watchPath = path10;
+    this.path = path10 = path10.replace(REPLACER_RE, "");
+    this.watchPath = watchPath;
+    this.fullWatchPath = sysPath2.resolve(watchPath);
+    this.dirParts = [];
+    this.dirParts.forEach((parts) => {
+      if (parts.length > 1)
+        parts.pop();
+    });
+    this.followSymlinks = follow;
+    this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
+  }
+  entryPath(entry) {
+    return sysPath2.join(this.watchPath, sysPath2.relative(this.watchPath, entry.fullPath));
+  }
+  filterPath(entry) {
+    const { stats } = entry;
+    if (stats && stats.isSymbolicLink())
+      return this.filterDir(entry);
+    const resolvedPath = this.entryPath(entry);
+    return this.fsw._isntIgnored(resolvedPath, stats) && this.fsw._hasReadPermissions(stats);
+  }
+  filterDir(entry) {
+    return this.fsw._isntIgnored(this.entryPath(entry), entry.stats);
+  }
+};
+var FSWatcher = class extends EventEmitter {
+  // Not indenting methods for history sake; for now.
+  constructor(_opts = {}) {
+    super();
+    this.closed = false;
+    this._closers = /* @__PURE__ */ new Map();
+    this._ignoredPaths = /* @__PURE__ */ new Set();
+    this._throttled = /* @__PURE__ */ new Map();
+    this._streams = /* @__PURE__ */ new Set();
+    this._symlinkPaths = /* @__PURE__ */ new Map();
+    this._watched = /* @__PURE__ */ new Map();
+    this._pendingWrites = /* @__PURE__ */ new Map();
+    this._pendingUnlinks = /* @__PURE__ */ new Map();
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    const awf = _opts.awaitWriteFinish;
+    const DEF_AWF = { stabilityThreshold: 2e3, pollInterval: 100 };
+    const opts = {
+      // Defaults
+      persistent: true,
+      ignoreInitial: false,
+      ignorePermissionErrors: false,
+      interval: 100,
+      binaryInterval: 300,
+      followSymlinks: true,
+      usePolling: false,
+      // useAsync: false,
+      atomic: true,
+      // NOTE: overwritten later (depends on usePolling)
+      ..._opts,
+      // Change format
+      ignored: _opts.ignored ? arrify(_opts.ignored) : arrify([]),
+      awaitWriteFinish: awf === true ? DEF_AWF : typeof awf === "object" ? { ...DEF_AWF, ...awf } : false
+    };
+    if (isIBMi)
+      opts.usePolling = true;
+    if (opts.atomic === void 0)
+      opts.atomic = !opts.usePolling;
+    const envPoll = process.env.CHOKIDAR_USEPOLLING;
+    if (envPoll !== void 0) {
+      const envLower = envPoll.toLowerCase();
+      if (envLower === "false" || envLower === "0")
+        opts.usePolling = false;
+      else if (envLower === "true" || envLower === "1")
+        opts.usePolling = true;
+      else
+        opts.usePolling = !!envLower;
+    }
+    const envInterval = process.env.CHOKIDAR_INTERVAL;
+    if (envInterval)
+      opts.interval = Number.parseInt(envInterval, 10);
+    let readyCalls = 0;
+    this._emitReady = () => {
+      readyCalls++;
+      if (readyCalls >= this._readyCount) {
+        this._emitReady = EMPTY_FN;
+        this._readyEmitted = true;
+        process.nextTick(() => this.emit(EVENTS.READY));
+      }
+    };
+    this._emitRaw = (...args) => this.emit(EVENTS.RAW, ...args);
+    this._boundRemove = this._remove.bind(this);
+    this.options = opts;
+    this._nodeFsHandler = new NodeFsHandler(this);
+    Object.freeze(opts);
+  }
+  _addIgnoredPath(matcher) {
+    if (isMatcherObject(matcher)) {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher.path && ignored.recursive === matcher.recursive) {
+          return;
+        }
+      }
+    }
+    this._ignoredPaths.add(matcher);
+  }
+  _removeIgnoredPath(matcher) {
+    this._ignoredPaths.delete(matcher);
+    if (typeof matcher === "string") {
+      for (const ignored of this._ignoredPaths) {
+        if (isMatcherObject(ignored) && ignored.path === matcher) {
+          this._ignoredPaths.delete(ignored);
+        }
+      }
+    }
+  }
+  // Public methods
+  /**
+   * Adds paths to be watched on an existing FSWatcher instance.
+   * @param paths_ file or file list. Other arguments are unused
+   */
+  add(paths_, _origAdd, _internal) {
+    const { cwd } = this.options;
+    this.closed = false;
+    this._closePromise = void 0;
+    let paths = unifyPaths(paths_);
+    if (cwd) {
+      paths = paths.map((path10) => {
+        const absPath = getAbsolutePath(path10, cwd);
+        return absPath;
+      });
+    }
+    paths.forEach((path10) => {
+      this._removeIgnoredPath(path10);
+    });
+    this._userIgnored = void 0;
+    if (!this._readyCount)
+      this._readyCount = 0;
+    this._readyCount += paths.length;
+    Promise.all(paths.map(async (path10) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path10, !_internal, void 0, 0, _origAdd);
+      if (res)
+        this._emitReady();
+      return res;
+    })).then((results) => {
+      if (this.closed)
+        return;
+      results.forEach((item) => {
+        if (item)
+          this.add(sysPath2.dirname(item), sysPath2.basename(_origAdd || item));
+      });
+    });
+    return this;
+  }
+  /**
+   * Close watchers or start ignoring events from specified paths.
+   */
+  unwatch(paths_) {
+    if (this.closed)
+      return this;
+    const paths = unifyPaths(paths_);
+    const { cwd } = this.options;
+    paths.forEach((path10) => {
+      if (!sysPath2.isAbsolute(path10) && !this._closers.has(path10)) {
+        if (cwd)
+          path10 = sysPath2.join(cwd, path10);
+        path10 = sysPath2.resolve(path10);
+      }
+      this._closePath(path10);
+      this._addIgnoredPath(path10);
+      if (this._watched.has(path10)) {
+        this._addIgnoredPath({
+          path: path10,
+          recursive: true
+        });
+      }
+      this._userIgnored = void 0;
+    });
+    return this;
+  }
+  /**
+   * Close watchers and remove all listeners from watched paths.
+   */
+  close() {
+    if (this._closePromise) {
+      return this._closePromise;
+    }
+    this.closed = true;
+    this.removeAllListeners();
+    const closers = [];
+    this._closers.forEach((closerList) => closerList.forEach((closer) => {
+      const promise = closer();
+      if (promise instanceof Promise)
+        closers.push(promise);
+    }));
+    this._streams.forEach((stream) => stream.destroy());
+    this._userIgnored = void 0;
+    this._readyCount = 0;
+    this._readyEmitted = false;
+    this._watched.forEach((dirent) => dirent.dispose());
+    this._closers.clear();
+    this._watched.clear();
+    this._streams.clear();
+    this._symlinkPaths.clear();
+    this._throttled.clear();
+    this._closePromise = closers.length ? Promise.all(closers).then(() => void 0) : Promise.resolve();
+    return this._closePromise;
+  }
+  /**
+   * Expose list of watched paths
+   * @returns for chaining
+   */
+  getWatched() {
+    const watchList = {};
+    this._watched.forEach((entry, dir) => {
+      const key = this.options.cwd ? sysPath2.relative(this.options.cwd, dir) : dir;
+      const index = key || ONE_DOT;
+      watchList[index] = entry.getChildren().sort();
+    });
+    return watchList;
+  }
+  emitWithAll(event, args) {
+    this.emit(event, ...args);
+    if (event !== EVENTS.ERROR)
+      this.emit(EVENTS.ALL, event, ...args);
+  }
+  // Common helpers
+  // --------------
+  /**
+   * Normalize and emit events.
+   * Calling _emit DOES NOT MEAN emit() would be called!
+   * @param event Type of event
+   * @param path File or directory path
+   * @param stats arguments to be passed with event
+   * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  async _emit(event, path10, stats) {
+    if (this.closed)
+      return;
+    const opts = this.options;
+    if (isWindows)
+      path10 = sysPath2.normalize(path10);
+    if (opts.cwd)
+      path10 = sysPath2.relative(opts.cwd, path10);
+    const args = [path10];
+    if (stats != null)
+      args.push(stats);
+    const awf = opts.awaitWriteFinish;
+    let pw;
+    if (awf && (pw = this._pendingWrites.get(path10))) {
+      pw.lastChange = /* @__PURE__ */ new Date();
+      return this;
+    }
+    if (opts.atomic) {
+      if (event === EVENTS.UNLINK) {
+        this._pendingUnlinks.set(path10, [event, ...args]);
+        setTimeout(() => {
+          this._pendingUnlinks.forEach((entry, path11) => {
+            this.emit(...entry);
+            this.emit(EVENTS.ALL, ...entry);
+            this._pendingUnlinks.delete(path11);
+          });
+        }, typeof opts.atomic === "number" ? opts.atomic : 100);
+        return this;
+      }
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path10)) {
+        event = EVENTS.CHANGE;
+        this._pendingUnlinks.delete(path10);
+      }
+    }
+    if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
+      const awfEmit = (err, stats2) => {
+        if (err) {
+          event = EVENTS.ERROR;
+          args[0] = err;
+          this.emitWithAll(event, args);
+        } else if (stats2) {
+          if (args.length > 1) {
+            args[1] = stats2;
+          } else {
+            args.push(stats2);
+          }
+          this.emitWithAll(event, args);
+        }
+      };
+      this._awaitWriteFinish(path10, awf.stabilityThreshold, event, awfEmit);
+      return this;
+    }
+    if (event === EVENTS.CHANGE) {
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path10, 50);
+      if (isThrottled)
+        return this;
+    }
+    if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
+      const fullPath = opts.cwd ? sysPath2.join(opts.cwd, path10) : path10;
+      let stats2;
+      try {
+        stats2 = await stat3(fullPath);
+      } catch (err) {
+      }
+      if (!stats2 || this.closed)
+        return;
+      args.push(stats2);
+    }
+    this.emitWithAll(event, args);
+    return this;
+  }
+  /**
+   * Common handler for errors
+   * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+   */
+  _handleError(error) {
+    const code = error && error.code;
+    if (error && code !== "ENOENT" && code !== "ENOTDIR" && (!this.options.ignorePermissionErrors || code !== "EPERM" && code !== "EACCES")) {
+      this.emit(EVENTS.ERROR, error);
+    }
+    return error || this.closed;
+  }
+  /**
+   * Helper utility for throttling
+   * @param actionType type being throttled
+   * @param path being acted upon
+   * @param timeout duration of time to suppress duplicate actions
+   * @returns tracking object or false if action should be suppressed
+   */
+  _throttle(actionType, path10, timeout) {
+    if (!this._throttled.has(actionType)) {
+      this._throttled.set(actionType, /* @__PURE__ */ new Map());
+    }
+    const action = this._throttled.get(actionType);
+    if (!action)
+      throw new Error("invalid throttle");
+    const actionPath = action.get(path10);
+    if (actionPath) {
+      actionPath.count++;
+      return false;
+    }
+    let timeoutObject;
+    const clear = () => {
+      const item = action.get(path10);
+      const count = item ? item.count : 0;
+      action.delete(path10);
+      clearTimeout(timeoutObject);
+      if (item)
+        clearTimeout(item.timeoutObject);
+      return count;
+    };
+    timeoutObject = setTimeout(clear, timeout);
+    const thr = { timeoutObject, clear, count: 0 };
+    action.set(path10, thr);
+    return thr;
+  }
+  _incrReadyCount() {
+    return this._readyCount++;
+  }
+  /**
+   * Awaits write operation to finish.
+   * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+   * @param path being acted upon
+   * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+   * @param event
+   * @param awfEmit Callback to be called when ready for event to be emitted.
+   */
+  _awaitWriteFinish(path10, threshold, event, awfEmit) {
+    const awf = this.options.awaitWriteFinish;
+    if (typeof awf !== "object")
+      return;
+    const pollInterval = awf.pollInterval;
+    let timeoutHandler;
+    let fullPath = path10;
+    if (this.options.cwd && !sysPath2.isAbsolute(path10)) {
+      fullPath = sysPath2.join(this.options.cwd, path10);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const writes = this._pendingWrites;
+    function awaitWriteFinishFn(prevStat) {
+      statcb(fullPath, (err, curStat) => {
+        if (err || !writes.has(path10)) {
+          if (err && err.code !== "ENOENT")
+            awfEmit(err);
+          return;
+        }
+        const now2 = Number(/* @__PURE__ */ new Date());
+        if (prevStat && curStat.size !== prevStat.size) {
+          writes.get(path10).lastChange = now2;
+        }
+        const pw = writes.get(path10);
+        const df = now2 - pw.lastChange;
+        if (df >= threshold) {
+          writes.delete(path10);
+          awfEmit(void 0, curStat);
+        } else {
+          timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
+        }
+      });
+    }
+    if (!writes.has(path10)) {
+      writes.set(path10, {
+        lastChange: now,
+        cancelWait: () => {
+          writes.delete(path10);
+          clearTimeout(timeoutHandler);
+          return event;
+        }
+      });
+      timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval);
+    }
+  }
+  /**
+   * Determines whether user has asked to ignore this path.
+   */
+  _isIgnored(path10, stats) {
+    if (this.options.atomic && DOT_RE.test(path10))
+      return true;
+    if (!this._userIgnored) {
+      const { cwd } = this.options;
+      const ign = this.options.ignored;
+      const ignored = (ign || []).map(normalizeIgnored(cwd));
+      const ignoredPaths = [...this._ignoredPaths];
+      const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
+      this._userIgnored = anymatch(list, void 0);
+    }
+    return this._userIgnored(path10, stats);
+  }
+  _isntIgnored(path10, stat4) {
+    return !this._isIgnored(path10, stat4);
+  }
+  /**
+   * Provides a set of common helpers and properties relating to symlink handling.
+   * @param path file or directory pattern being watched
+   */
+  _getWatchHelpers(path10) {
+    return new WatchHelper(path10, this.options.followSymlinks, this);
+  }
+  // Directory helpers
+  // -----------------
+  /**
+   * Provides directory tracking objects
+   * @param directory path of the directory
+   */
+  _getWatchedDir(directory) {
+    const dir = sysPath2.resolve(directory);
+    if (!this._watched.has(dir))
+      this._watched.set(dir, new DirEntry(dir, this._boundRemove));
+    return this._watched.get(dir);
+  }
+  // File helpers
+  // ------------
+  /**
+   * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+   */
+  _hasReadPermissions(stats) {
+    if (this.options.ignorePermissionErrors)
+      return true;
+    return Boolean(Number(stats.mode) & 256);
+  }
+  /**
+   * Handles emitting unlink events for
+   * files and directories, and via recursion, for
+   * files and directories within directories that are unlinked
+   * @param directory within which the following item is located
+   * @param item      base path of item/directory
+   */
+  _remove(directory, item, isDirectory) {
+    const path10 = sysPath2.join(directory, item);
+    const fullPath = sysPath2.resolve(path10);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path10) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path10, 100))
+      return;
+    if (!isDirectory && this._watched.size === 1) {
+      this.add(directory, item, true);
+    }
+    const wp = this._getWatchedDir(path10);
+    const nestedDirectoryChildren = wp.getChildren();
+    nestedDirectoryChildren.forEach((nested) => this._remove(path10, nested));
+    const parent = this._getWatchedDir(directory);
+    const wasTracked = parent.has(item);
+    parent.remove(item);
+    if (this._symlinkPaths.has(fullPath)) {
+      this._symlinkPaths.delete(fullPath);
+    }
+    let relPath = path10;
+    if (this.options.cwd)
+      relPath = sysPath2.relative(this.options.cwd, path10);
+    if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
+      const event = this._pendingWrites.get(relPath).cancelWait();
+      if (event === EVENTS.ADD)
+        return;
+    }
+    this._watched.delete(path10);
+    this._watched.delete(fullPath);
+    const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
+    if (wasTracked && !this._isIgnored(path10))
+      this._emit(eventName, path10);
+    this._closePath(path10);
+  }
+  /**
+   * Closes all watchers for a path
+   */
+  _closePath(path10) {
+    this._closeFile(path10);
+    const dir = sysPath2.dirname(path10);
+    this._getWatchedDir(dir).remove(sysPath2.basename(path10));
+  }
+  /**
+   * Closes only file-specific watchers
+   */
+  _closeFile(path10) {
+    const closers = this._closers.get(path10);
+    if (!closers)
+      return;
+    closers.forEach((closer) => closer());
+    this._closers.delete(path10);
+  }
+  _addPathCloser(path10, closer) {
+    if (!closer)
+      return;
+    let list = this._closers.get(path10);
+    if (!list) {
+      list = [];
+      this._closers.set(path10, list);
+    }
+    list.push(closer);
+  }
+  _readdirp(root, opts) {
+    if (this.closed)
+      return;
+    const options = { type: EVENTS.ALL, alwaysStat: true, lstat: true, ...opts, depth: 0 };
+    let stream = readdirp(root, options);
+    this._streams.add(stream);
+    stream.once(STR_CLOSE, () => {
+      stream = void 0;
+    });
+    stream.once(STR_END, () => {
+      if (stream) {
+        this._streams.delete(stream);
+        stream = void 0;
+      }
+    });
+    return stream;
+  }
+};
+function watch(paths, options = {}) {
+  const watcher = new FSWatcher(options);
+  watcher.add(paths);
+  return watcher;
+}
+var esm_default = { watch, FSWatcher };
+
+// ../../apps/server/src/services/session-broadcaster.ts
+import { join as join3 } from "path";
+var SessionBroadcaster = class {
+  constructor(transcriptReader2) {
+    this.transcriptReader = transcriptReader2;
+  }
+  clients = /* @__PURE__ */ new Map();
+  watchers = /* @__PURE__ */ new Map();
+  offsets = /* @__PURE__ */ new Map();
+  debounceTimers = /* @__PURE__ */ new Map();
+  /**
+   * Register an SSE client for a session.
+   *
+   * - Adds the response to the set of connected clients
+   * - Starts a file watcher if none exists for this session
+   * - Initializes offset to current file size (only broadcast new content)
+   * - Sends sync_connected event to the client
+   * - Auto-deregisters on response close
+   *
+   * @param sessionId - Session UUID
+   * @param vaultRoot - Vault root path for resolving transcript directory
+   * @param res - Express Response object configured for SSE
+   */
+  registerClient(sessionId, vaultRoot2, res) {
+    if (!this.clients.has(sessionId)) {
+      this.clients.set(sessionId, /* @__PURE__ */ new Set());
+    }
+    this.clients.get(sessionId).add(res);
+    if (!this.watchers.has(sessionId)) {
+      this.startWatcher(sessionId, vaultRoot2);
+    }
+    res.write(`event: sync_connected
+data: ${JSON.stringify({ sessionId })}
+
+`);
+    res.on("close", () => {
+      this.deregisterClient(sessionId, res);
+    });
+  }
+  /**
+   * Deregister an SSE client from a session.
+   *
+   * - Removes the response from the client set
+   * - Stops the file watcher if no clients remain for this session
+   * - Cleans up offsets and timers
+   *
+   * @param sessionId - Session UUID
+   * @param res - Express Response object to remove
+   */
+  deregisterClient(sessionId, res) {
+    const clientSet = this.clients.get(sessionId);
+    if (!clientSet) return;
+    clientSet.delete(res);
+    if (clientSet.size === 0) {
+      this.clients.delete(sessionId);
+      const watcher = this.watchers.get(sessionId);
+      if (watcher) {
+        watcher.close();
+        this.watchers.delete(sessionId);
+      }
+      this.offsets.delete(sessionId);
+      const timer = this.debounceTimers.get(sessionId);
+      if (timer) {
+        clearTimeout(timer);
+        this.debounceTimers.delete(sessionId);
+      }
+    }
+  }
+  /**
+   * Start a chokidar file watcher for a session's JSONL transcript.
+   *
+   * Watches the SDK transcript file and broadcasts updates on change events.
+   * Changes are debounced (100ms) to batch rapid writes during streaming.
+   *
+   * @param sessionId - Session UUID
+   * @param vaultRoot - Vault root path for resolving transcript directory
+   */
+  startWatcher(sessionId, vaultRoot2) {
+    const transcriptsDir = this.transcriptReader.getTranscriptsDir(vaultRoot2);
+    const filePath = join3(transcriptsDir, `${sessionId}.jsonl`);
+    this.initializeOffset(vaultRoot2, sessionId);
+    const watcher = esm_default.watch(filePath, {
+      persistent: true,
+      ignoreInitial: true,
+      // Don't fire for initial file scan
+      awaitWriteFinish: {
+        stabilityThreshold: 50,
+        pollInterval: 25
+      }
+    });
+    watcher.on("change", () => {
+      const existingTimer = this.debounceTimers.get(sessionId);
+      if (existingTimer) {
+        clearTimeout(existingTimer);
+      }
+      const timer = setTimeout(() => {
+        this.debounceTimers.delete(sessionId);
+        this.broadcastUpdate(sessionId, vaultRoot2).catch((err) => {
+          console.error(`[SessionBroadcaster] Failed to broadcast update for session ${sessionId}:`, err);
+        });
+      }, 100);
+      this.debounceTimers.set(sessionId, timer);
+    });
+    this.watchers.set(sessionId, watcher);
+  }
+  /**
+   * Initialize the byte offset for a session to the current file size.
+   * This ensures we only broadcast new content, not existing history.
+   *
+   * @param vaultRoot - Vault root path
+   * @param sessionId - Session UUID
+   */
+  async initializeOffset(vaultRoot2, sessionId) {
+    try {
+      const { newOffset } = await this.transcriptReader.readFromOffset(vaultRoot2, sessionId, 0);
+      this.offsets.set(sessionId, newOffset);
+    } catch (err) {
+      this.offsets.set(sessionId, 0);
+    }
+  }
+  /**
+   * Broadcast a sync_update event to all connected clients for a session.
+   *
+   * Reads new content from the transcript file since the last offset and
+   * sends a sync_update SSE event if new content exists.
+   *
+   * @param sessionId - Session UUID
+   * @param vaultRoot - Vault root path
+   */
+  async broadcastUpdate(sessionId, vaultRoot2) {
+    const currentOffset = this.offsets.get(sessionId) ?? 0;
+    try {
+      const { content, newOffset } = await this.transcriptReader.readFromOffset(
+        vaultRoot2,
+        sessionId,
+        currentOffset
+      );
+      this.offsets.set(sessionId, newOffset);
+      if (content.length === 0) {
+        return;
+      }
+      const clientSet = this.clients.get(sessionId);
+      if (!clientSet || clientSet.size === 0) {
+        return;
+      }
+      const event = {
+        sessionId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const eventData = `event: sync_update
+data: ${JSON.stringify(event)}
+
+`;
+      for (const client of Array.from(clientSet)) {
+        try {
+          client.write(eventData);
+        } catch (err) {
+          console.error(`[SessionBroadcaster] Failed to write to client for session ${sessionId}:`, err);
+        }
+      }
+    } catch (err) {
+      console.error(`[SessionBroadcaster] Failed to read offset for session ${sessionId}:`, err);
+    }
+  }
+  /**
+   * Shutdown the broadcaster, closing all watchers and client connections.
+   * Should be called on server shutdown.
+   */
+  shutdown() {
+    Array.from(this.debounceTimers.values()).forEach((timer) => {
+      clearTimeout(timer);
+    });
+    this.debounceTimers.clear();
+    Array.from(this.watchers.values()).forEach((watcher) => {
+      watcher.close();
+    });
+    this.watchers.clear();
+    Array.from(this.clients.values()).forEach((clientSet) => {
+      Array.from(clientSet).forEach((client) => {
+        try {
+          client.end();
+        } catch {
+        }
+      });
+    });
+    this.clients.clear();
+    this.offsets.clear();
+  }
+};
+
+// ../../apps/server/src/index.ts
+var __dirname5 = path9.dirname(fileURLToPath5(import.meta.url));
+if (!process.env.CLIENT_DIST_PATH) {
+  dotenv.config({ path: path9.join(__dirname5, "../../../.env") });
+}
+var PORT = parseInt(process.env.GATEWAY_PORT || "6942", 10);
+var sessionBroadcaster = null;
+async function start() {
+  const app = createApp();
+  sessionBroadcaster = new SessionBroadcaster(transcriptReader);
+  app.locals.sessionBroadcaster = sessionBroadcaster;
+  const host = process.env.TUNNEL_ENABLED === "true" ? "0.0.0.0" : "localhost";
+  app.listen(PORT, host, () => {
+    console.log(`Gateway server running on http://localhost:${PORT}`);
+  });
+  setInterval(() => {
+    agentManager.checkSessionHealth();
+  }, 5 * 60 * 1e3);
+  if (process.env.TUNNEL_ENABLED === "true") {
+    const tunnelPort = parseInt(process.env.TUNNEL_PORT || String(PORT), 10);
+    try {
+      const url = await tunnelManager.start({
+        port: tunnelPort,
+        authtoken: process.env.NGROK_AUTHTOKEN,
+        basicAuth: process.env.TUNNEL_AUTH,
+        domain: process.env.TUNNEL_DOMAIN
+      });
+      const hasAuth = !!process.env.TUNNEL_AUTH;
+      const isDevPort = tunnelPort !== PORT;
+      console.log("");
+      console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+      console.log("\u2502  ngrok tunnel active                            \u2502");
+      console.log("\u2502                                                 \u2502");
+      console.log(`\u2502  URL:  ${url.padEnd(40)} \u2502`);
+      console.log(`\u2502  Port: ${String(tunnelPort).padEnd(40)} \u2502`);
+      console.log(`\u2502  Auth: ${(hasAuth ? "basic auth enabled" : "none (open)").padEnd(40)} \u2502`);
+      if (isDevPort) {
+        console.log(`\u2502  Mode: ${("dev (Vite on :" + tunnelPort + ")").padEnd(40)} \u2502`);
+      }
+      console.log("\u2502                                                 \u2502");
+      console.log("\u2502  Free tier: 1GB/month bandwidth, session limits \u2502");
+      console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+      console.log("");
+    } catch (err) {
+      console.warn("[Tunnel] Failed to start ngrok tunnel:", err instanceof Error ? err.message : err);
+      console.warn("[Tunnel] Server continues without tunnel.");
+    }
+  }
+}
+function shutdown() {
+  console.log("\nShutting down...");
+  if (sessionBroadcaster) {
+    sessionBroadcaster.shutdown();
+  }
+  tunnelManager.stop().finally(() => {
+    process.exit(0);
+  });
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+start();
+/*! Bundled license information:
+
+chokidar/esm/index.js:
+  (*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=index.js.map