@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/idecron.ts

@@ -0,0 +1,271 @@
+import crypto from "node:crypto";
+import { CronExpressionParser } from "cron-parser";
+import type { CronInfo } from "../shared/protocol.ts";
+import { db } from "./db.ts";
+
+export type IdeCronMode = "steer" | "next_turn" | "interrupt";
+
+export type IdeCronTask = {
+  id: string;
+  sessionId: string;
+  projectPath: string;
+  prompt: string;
+  /** The expression the user/agent supplied, kept for display. */
+  schedule: string;
+  /** Parsed cron expression for recurring tasks. */
+  cron?: string;
+  recurring: boolean;
+  mode: IdeCronMode;
+  nextRunAt: number;
+  lastRunAt?: number;
+  createdAt: number;
+};
+
+type Row = {
+  id: string;
+  session_id: string;
+  project_path: string;
+  prompt: string;
+  schedule: string;
+  cron: string | null;
+  recurring: number;
+  mode: string;
+  next_run_at: number;
+  last_run_at: number | null;
+  created_at: number;
+};
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS idecron_schedules (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    project_path TEXT NOT NULL,
+    prompt TEXT NOT NULL,
+    schedule TEXT NOT NULL,
+    cron TEXT,
+    recurring INTEGER NOT NULL,
+    mode TEXT NOT NULL,
+    next_run_at INTEGER NOT NULL,
+    last_run_at INTEGER,
+    created_at INTEGER NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idecron_next_run ON idecron_schedules(next_run_at);
+  CREATE INDEX IF NOT EXISTS idecron_session ON idecron_schedules(session_id);
+`);
+
+const MODES: IdeCronMode[] = ["steer", "next_turn", "interrupt"];
+const INTERVAL = /^(\d+)\s*(s|m|h|d)$/i;
+
+function rowTask(row: Row): IdeCronTask {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    projectPath: row.project_path,
+    prompt: row.prompt,
+    schedule: row.schedule,
+    ...(row.cron ? { cron: row.cron } : {}),
+    recurring: row.recurring === 1,
+    mode: MODES.includes(row.mode as IdeCronMode) ? (row.mode as IdeCronMode) : "steer",
+    nextRunAt: row.next_run_at,
+    ...(typeof row.last_run_at === "number" ? { lastRunAt: row.last_run_at } : {}),
+    createdAt: row.created_at,
+  };
+}
+
+function nextCron(cron: string, from = Date.now()): number | undefined {
+  try {
+    return CronExpressionParser.parse(cron, { currentDate: new Date(from) }).next().getTime();
+  } catch {
+    return undefined;
+  }
+}
+
+function intervalCron(n: number, unit: string): string | undefined {
+  if (unit === "s") return undefined;
+  if (unit === "m") {
+    if (n < 1 || n > 59) return undefined;
+    return n === 1 ? "* * * * *" : `*/${n} * * * *`;
+  }
+  if (unit === "h") {
+    if (n < 1 || n > 23) return undefined;
+    return n === 1 ? "0 * * * *" : `0 */${n} * * *`;
+  }
+  if (n < 1 || n > 28) return undefined;
+  return n === 1 ? "0 0 * * *" : `0 0 */${n} * *`;
+}
+
+function parseWhen(when: string, recurring: boolean | undefined): {
+  schedule: string;
+  cron?: string;
+  recurring: boolean;
+  nextRunAt: number;
+} {
+  const value = when.trim();
+  if (!value) throw new Error("when 不能为空");
+
+  const interval = INTERVAL.exec(value);
+  if (interval) {
+    const n = Number(interval[1]);
+    const unit = interval[2]!.toLowerCase();
+    const repeat = recurring ?? true;
+    if (!repeat) {
+      const ms = n * (unit === "s" ? 1_000 : unit === "m" ? 60_000 : unit === "h" ? 3_600_000 : 86_400_000);
+      if (ms < 60_000) throw new Error("间隔至少 1 分钟");
+      return { schedule: value, recurring: false, nextRunAt: Date.now() + ms };
+    }
+    const cron = intervalCron(n, unit);
+    if (!cron) throw new Error("重复间隔至少 1 分钟；秒级任务不受支持");
+    const nextRunAt = nextCron(cron);
+    if (nextRunAt === undefined) throw new Error(`无法解析间隔：${value}`);
+    return { schedule: value, cron, recurring: true, nextRunAt };
+  }
+
+  const iso = Date.parse(value);
+  if (Number.isFinite(iso) && !/^\d+\s+\d+\s+\d+\s+\d+\s+\d+$/.test(value)) {
+    if (recurring === true) throw new Error("ISO 时间只能创建一次性任务");
+    if (iso <= Date.now()) throw new Error("这个时间已经过去了");
+    return { schedule: value, recurring: false, nextRunAt: iso };
+  }
+
+  const repeat = recurring ?? true;
+  const nextRunAt = nextCron(value);
+  if (nextRunAt === undefined) throw new Error(`无法解析时间：${value}`);
+  return { schedule: value, cron: repeat ? value : undefined, recurring: repeat, nextRunAt };
+}
+
+function notify(sessionId: string) {
+  idecron.onChange?.(sessionId);
+}
+
+class IdeCron {
+  onChange?: (sessionId: string) => void;
+  private timer?: NodeJS.Timeout;
+  private ticking = false;
+  private retry = new Map<string, number>();
+  private delivery?: {
+    canDeliver: (task: IdeCronTask) => boolean;
+    deliver: (task: IdeCronTask) => Promise<boolean> | boolean;
+  };
+
+  setDelivery(delivery: NonNullable<IdeCron["delivery"]>) {
+    this.delivery = delivery;
+  }
+
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => void this.tick(), 1_000);
+    this.timer.unref();
+    void this.tick();
+  }
+
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = undefined;
+  }
+
+  create(input: {
+    sessionId: string;
+    projectPath: string;
+    when: string;
+    prompt: string;
+    recurring?: boolean;
+    mode?: IdeCronMode;
+  }): IdeCronTask {
+    const prompt = input.prompt.trim();
+    if (!prompt) throw new Error("prompt 不能为空");
+    const mode = input.mode ?? "steer";
+    if (!MODES.includes(mode)) throw new Error("未知的执行方式");
+    const parsed = parseWhen(input.when, input.recurring);
+    const task: IdeCronTask = {
+      id: crypto.randomUUID(),
+      sessionId: input.sessionId,
+      projectPath: input.projectPath,
+      prompt,
+      schedule: parsed.schedule,
+      ...(parsed.cron ? { cron: parsed.cron } : {}),
+      recurring: parsed.recurring,
+      mode,
+      nextRunAt: parsed.nextRunAt,
+      createdAt: Date.now(),
+    };
+    db.prepare(`INSERT INTO idecron_schedules
+      (id, session_id, project_path, prompt, schedule, cron, recurring, mode, next_run_at, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
+      task.id, task.sessionId, task.projectPath, task.prompt, task.schedule,
+      task.cron ?? null, task.recurring ? 1 : 0, task.mode, task.nextRunAt, task.createdAt,
+    );
+    notify(task.sessionId);
+    return task;
+  }
+
+  list(sessionId: string): IdeCronTask[] {
+    const rows = db.prepare("SELECT * FROM idecron_schedules WHERE session_id = ? ORDER BY next_run_at").all(sessionId) as Row[];
+    return rows.map(rowTask);
+  }
+
+  cronsFor(sessionId: string): CronInfo[] {
+    return this.list(sessionId).map((task) => ({
+      id: task.id,
+      schedule: task.schedule,
+      recurring: task.recurring,
+      prompt: task.prompt,
+      nextRun: task.nextRunAt,
+      server: true,
+      mode: task.mode,
+    }));
+  }
+
+  count(sessionId: string): number {
+    return (db.prepare("SELECT COUNT(*) AS n FROM idecron_schedules WHERE session_id = ?").get(sessionId) as { n: number }).n;
+  }
+
+  cancel(id: string, sessionId?: string): boolean {
+    const row = db.prepare("SELECT session_id FROM idecron_schedules WHERE id = ?").get(id) as { session_id: string } | undefined;
+    if (!row || sessionId !== undefined && row.session_id !== sessionId) return false;
+    db.prepare("DELETE FROM idecron_schedules WHERE id = ?").run(id);
+    this.retry.delete(id);
+    notify(row.session_id);
+    return true;
+  }
+
+  cancelSession(sessionId: string): void {
+    const ids = db.prepare("SELECT id FROM idecron_schedules WHERE session_id = ?").all(sessionId) as { id: string }[];
+    db.prepare("DELETE FROM idecron_schedules WHERE session_id = ?").run(sessionId);
+    for (const { id } of ids) this.retry.delete(id);
+  }
+
+  async tick(now = Date.now()): Promise<void> {
+    if (this.ticking) return;
+    this.ticking = true;
+    try {
+      const due = db.prepare("SELECT * FROM idecron_schedules WHERE next_run_at <= ? ORDER BY next_run_at LIMIT 20").all(now) as Row[];
+      for (const row of due) {
+        const task = rowTask(row);
+        if ((this.retry.get(task.id) ?? 0) > now) continue;
+        if (task.mode === "next_turn" && this.delivery && !this.delivery.canDeliver(task)) continue;
+        if (!this.delivery) continue;
+        let delivered = false;
+        try {
+          delivered = await this.delivery.deliver(task);
+        } catch (err) {
+          console.warn(`IDECron delivery failed for ${task.id}: ${err instanceof Error ? err.message : err}`);
+          this.retry.set(task.id, now + 60_000);
+          continue;
+        }
+        if (!delivered) continue;
+        this.retry.delete(task.id);
+        const next = task.recurring && task.cron ? nextCron(task.cron) : undefined;
+        if (next !== undefined) {
+          db.prepare("UPDATE idecron_schedules SET next_run_at = ?, last_run_at = ? WHERE id = ?").run(next, now, task.id);
+        } else {
+          db.prepare("DELETE FROM idecron_schedules WHERE id = ?").run(task.id);
+        }
+        notify(task.sessionId);
+      }
+    } finally {
+      this.ticking = false;
+    }
+  }
+}
+
+export const idecron = new IdeCron();

package/server/index.ts

@@ -0,0 +1,336 @@
+import "./report-cache.ts";
+import fs from "node:fs";
+import path from "node:path";
+import { Hono } from "hono";
+import { compress } from "hono/compress";
+import { serve } from "@hono/node-server";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { createNodeWebSocket } from "@hono/node-ws";
+import { config } from "./config.ts";
+import { authToken, clientAddress, isAuthed, login, loginLockedFor, recordLogin, requireAuth, revokeToken, sameOrigin, watchPassword } from "./auth.ts";
+import {
+  HttpError,
+  addProject,
+  createDraftSession,
+  listProjectSessions,
+  sessionFileInfo,
+  listProjects,
+  projectPath,
+  removeProject,
+  sessionHistory,
+  sessionHistoryPage,
+  sessionHistoryMessage,
+  sessions,
+  updateSession,
+  removeSession,
+  forkAt,
+  rewind,
+  pendingRewindDraft,
+  exportSession,
+  type RewindMode,
+  overview,
+  changeSessionDir,
+} from "./sessions.ts";
+import { goalState, isSessionId } from "./session-file.ts";
+import { commandList, modelOptions } from "./cli-info.ts";
+import { listSessionSubagents, subagentMessages, subagentHistoryPage, subagentHistoryMessage } from "./subagents.ts";
+import { askBtw, btwInfo, promoteBtw } from "./btw.ts";
+import { closeConn, handleMessage, openConn, revokeConnections } from "./ws.ts";
+import { registerFileRoutes } from "./files.ts";
+import { registerToolImageRoutes } from "./tool-images.ts";
+import { registerConfigRoutes } from "./config/routes.ts";
+import { closeAllControl } from "./cli-control.ts";
+import { registerPushRoutes } from "./push.ts";
+import { registerProjectRoutes } from "./project-routes.ts";
+import { registerDirectoryRoutes } from "./directories.ts";
+import { watchDistVersion } from "./dist-version.ts";
+import { registerHttpChannelRoutes } from "./http-channel-routes.ts";
+import { httpChannels } from "./http-channel-manager.ts";
+import { idecron } from "./idecron.ts";
+import { HistoryError } from "./history-pages.ts";
+
+const app = new Hono();
+const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
+
+app.onError((err, c) => {
+  if (err instanceof HttpError || err instanceof HistoryError) return c.json({ error: err.message }, err.status);
+  console.error(err);
+  return c.json({ error: err.message || "internal error" }, 500);
+});
+
+// JSON (a long session's history is megabytes) and built assets go out gzipped: phones on LAN/Tailscale.
+app.use("/api/*", compress());
+app.use("/assets/*", compress());
+
+app.get("/api/health", (c) => c.json({ ok: true }));
+
+app.get("/api/auth", async (c) => c.json({ authed: await isAuthed(c) }));
+
+app.post("/api/login", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  const password = typeof body?.password === "string" ? body.password : "";
+  const addr = clientAddress(c);
+  const wait = loginLockedFor(addr);
+  if (wait) return c.json({ error: `尝试次数太多，请 ${Math.ceil(wait / 60)} 分钟后再试` }, 429);
+  const ok = await login(c, password);
+  recordLogin(addr, ok);
+  if (!ok) return c.json({ error: "密码不正确" }, 401);
+  return c.json({ ok: true });
+});
+
+app.post("/api/logout", (c) => {
+  const token = revokeToken(c);
+  if (token) revokeConnections(token);
+  return c.json({ ok: true });
+});
+
+app.get(
+  "/ws",
+  upgradeWebSocket(async (c) => {
+    if (!await isAuthed(c) || !sameOrigin(c)) {
+      return { onOpen: (_e, ws) => ws.close(4401, "unauthorized") };
+    }
+    const token = authToken(c)!;
+    let conn: ReturnType<typeof openConn>;
+    return {
+      onOpen: (_e, ws) => {
+        conn = openConn(ws, token);
+      },
+      onMessage: (e) => {
+        if (conn) void handleMessage(conn, String(e.data));
+      },
+      onClose: () => {
+        if (conn) closeConn(conn);
+      },
+    };
+  }),
+);
+
+app.use("/api/*", requireAuth);
+// State-changing requests must come from this app's own pages.
+app.use("/api/*", async (c, next) => {
+  if (c.req.method !== "GET" && c.req.method !== "HEAD" && !sameOrigin(c)) return c.json({ error: "forbidden" }, 403);
+  await next();
+});
+
+app.get("/api/projects", async (c) => c.json(await listProjects()));
+
+app.post("/api/projects", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  try {
+    return c.json(await addProject(String(body?.path ?? "")));
+  } catch (err) {
+    throw new HttpError(400, (err as Error).message);
+  }
+});
+
+app.delete("/api/projects/:pid", (c) => {
+  removeProject(c.req.param("pid"));
+  return c.json({ ok: true });
+});
+
+app.get("/api/projects/:pid/sessions", async (c) => c.json(await listProjectSessions(projectPath(c.req.param("pid")))));
+
+app.post("/api/projects/:pid/sessions", (c) => c.json({ id: createDraftSession(projectPath(c.req.param("pid"))) }));
+
+app.get("/api/projects/:pid/sessions/:sid/info", async (c) => {
+  const sid = c.req.param("sid");
+  if (!isSessionId(sid)) throw new HttpError(400, "会话 ID 格式不正确");
+  const info = await sessionFileInfo(sid, projectPath(c.req.param("pid")));
+  if (!info) throw new HttpError(404, "会话不存在");
+  return c.json(info);
+});
+
+app.get("/api/projects/:pid/sessions/:sid/messages", async (c) => {
+  const sid = c.req.param("sid");
+  const project = projectPath(c.req.param("pid"));
+  // Keep the old response for older clients and export consumers.
+  if (c.req.query("page") !== "1") return c.json(await sessionHistory(sid, project));
+  return c.json(await sessionHistoryPage(sid, project, { cursor: c.req.query("cursor"), before: c.req.query("before"), after: c.req.query("after") }));
+});
+
+app.get("/api/projects/:pid/sessions/:sid/messages/:uuid", async (c) =>
+  c.json(await sessionHistoryMessage(c.req.param("sid"), projectPath(c.req.param("pid")), c.req.param("uuid"))),
+);
+
+app.patch("/api/projects/:pid/sessions/:sid", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  if (body.askQuestionsEnabled !== undefined && typeof body.askQuestionsEnabled !== "boolean") throw new HttpError(400, "提问设置应为开关值");
+  if (body.writeEnabled !== undefined && typeof body.writeEnabled !== "boolean") throw new HttpError(400, "写入设置应为开关值");
+  await updateSession(c.req.param("sid"), projectPath(c.req.param("pid")), {
+    title: typeof body.title === "string" ? body.title : undefined,
+    pinned: typeof body.pinned === "boolean" ? body.pinned : undefined,
+    archived: typeof body.archived === "boolean" ? body.archived : undefined,
+    askQuestionsEnabled: body.askQuestionsEnabled,
+    writeEnabled: body.writeEnabled,
+  });
+  return c.json({ ok: true });
+});
+
+app.delete("/api/projects/:pid/sessions/:sid", async (c) => {
+  await removeSession(c.req.param("sid"), projectPath(c.req.param("pid")));
+  return c.json({ ok: true });
+});
+
+app.post("/api/projects/:pid/sessions/:sid/fork", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  const id = await forkAt(c.req.param("sid"), projectPath(c.req.param("pid")), typeof body.beforeUuid === "string" ? body.beforeUuid : undefined);
+  return c.json({ id });
+});
+
+app.post("/api/projects/:pid/sessions/:sid/rewind", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  const mode = body.mode as RewindMode;
+  if (!["conversation", "code", "both"].includes(mode) || typeof body.userUuid !== "string") throw new HttpError(400, "bad request");
+  return c.json(await rewind(c.req.param("sid"), projectPath(c.req.param("pid")), body.userUuid, mode, !!body.dryRun));
+});
+
+app.get("/api/projects/:pid/sessions/:sid/draft", (c) => c.json(pendingRewindDraft(c.req.param("sid"))));
+
+app.get("/api/projects/:pid/sessions/:sid/export", async (c) => {
+  const { text, filename } = await exportSession(c.req.param("sid"), projectPath(c.req.param("pid")));
+  c.header("content-disposition", `attachment; filename*=UTF-8''${encodeURIComponent(filename)}`);
+  return c.text(text);
+});
+
+app.get("/api/overview", async (c) => c.json(await overview()));
+
+app.post("/api/projects/:pid/sessions/:sid/cd", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  try {
+    return c.json(await changeSessionDir(c.req.param("sid"), projectPath(c.req.param("pid")), String(body?.path ?? "")));
+  } catch (err) {
+    if (err instanceof HttpError) throw err;
+    throw new HttpError(400, (err as Error).message);
+  }
+});
+
+app.post("/api/projects/:pid/sessions/:sid/feedback", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  const text = String(body?.description ?? "").trim();
+  if (!text) throw new HttpError(400, "请填写反馈内容");
+  const live = await sessions.getOrCreate(c.req.param("sid"), projectPath(c.req.param("pid")));
+  return c.json({ ok: true, result: await live.submitFeedback(text, !!body?.attachTranscript) });
+});
+
+app.get("/api/projects/:pid/sessions/:sid/goal", async (c) => c.json(await goalState(projectPath(c.req.param("pid")), c.req.param("sid"))));
+
+app.get("/api/projects/:pid/sessions/:sid/tasks/:tid/output", async (c) => {
+  projectPath(c.req.param("pid"));
+  const s = sessions.get(c.req.param("sid"));
+  return c.json(s ? await s.taskOutput(c.req.param("tid")).catch((e) => ({ output: "", error: String(e?.message ?? e) })) : { output: "" });
+});
+
+app.post("/api/projects/:pid/sessions/:sid/tasks/:tid/stop", async (c) => {
+  projectPath(c.req.param("pid"));
+  await sessions.get(c.req.param("sid"))?.stopTask(c.req.param("tid"));
+  return c.json({ ok: true });
+});
+
+app.post("/api/projects/:pid/sessions/:sid/tools/:tid/background", async (c) => {
+  projectPath(c.req.param("pid"));
+  const session = sessions.get(c.req.param("sid"));
+  if (!session || !(await session.backgroundTask(c.req.param("tid")))) {
+    throw new HttpError(409, "该命令已结束或已转入后台");
+  }
+  return c.json({ ok: true });
+});
+
+app.get("/api/projects/:pid/sessions/:sid/subagents", async (c) =>
+  c.json(await listSessionSubagents(projectPath(c.req.param("pid")), c.req.param("sid"))),
+);
+
+app.get("/api/projects/:pid/sessions/:sid/subagents/:aid/messages", async (c) => {
+  const project = projectPath(c.req.param("pid"));
+  const sid = c.req.param("sid");
+  const aid = c.req.param("aid");
+  if (c.req.query("page") !== "1") return c.json(await subagentMessages(project, sid, aid));
+  const historyRevision = (await sessions.getOrCreate(sid, project)).historyRevision;
+  const page = await subagentHistoryPage(project, sid, aid, { cursor: c.req.query("cursor"), before: c.req.query("before"), after: c.req.query("after") });
+  return c.json({ ...page, historyRevision });
+});
+app.get("/api/projects/:pid/sessions/:sid/subagents/:aid/messages/:uuid", async (c) =>
+  c.json(await subagentHistoryMessage(projectPath(c.req.param("pid")), c.req.param("sid"), c.req.param("aid"), c.req.param("uuid"))),
+);
+
+app.get("/api/projects/:pid/models", async (c) => c.json(await modelOptions(projectPath(c.req.param("pid")))));
+
+registerFileRoutes(app);
+registerToolImageRoutes(app);
+registerDirectoryRoutes(app);
+// Config written from the settings pages: running sessions pick it up (see LiveSession.reloadConfig).
+app.use("/api/config/*", async (c, next) => {
+  await next();
+  if (c.req.method !== "GET" && c.res.ok) await sessions.configChanged();
+});
+registerConfigRoutes(app);
+registerPushRoutes(app);
+registerProjectRoutes(app);
+
+// ---------- composer: commands, /btw, context ----------
+
+app.get("/api/projects/:pid/commands", async (c) => c.json(await commandList(projectPath(c.req.param("pid")))));
+
+app.get("/api/projects/:pid/sessions/:sid/btw", async (c) => c.json(await btwInfo(projectPath(c.req.param("pid")), c.req.param("sid"))));
+
+app.post("/api/projects/:pid/sessions/:sid/btw", async (c) => {
+  const body = await c.req.json().catch(() => ({}));
+  return c.json(await askBtw(projectPath(c.req.param("pid")), c.req.param("sid"), String(body?.question ?? "")));
+});
+
+app.post("/api/projects/:pid/sessions/:sid/promote", (c) => {
+  promoteBtw(projectPath(c.req.param("pid")), c.req.param("sid"));
+  return c.json({ ok: true });
+});
+
+app.get("/api/projects/:pid/sessions/:sid/context", async (c) => {
+  projectPath(c.req.param("pid"));
+  const usage = await sessions.get(c.req.param("sid"))?.contextUsage().catch(() => undefined);
+  if (!usage) return c.json(null);
+  return c.json({
+    totalTokens: usage.totalTokens,
+    maxTokens: usage.maxTokens,
+    percentage: usage.percentage,
+    model: usage.model,
+    categories: usage.categories.map((k) => ({ name: k.name, tokens: k.tokens, kind: k.kind })),
+  });
+});
+
+registerHttpChannelRoutes(app);
+app.all("/api/*", (c) => c.json({ error: "not found" }, 404));
+
+if (config.production) {
+  app.use("/*", async (c, next) => {
+    await next();
+    if ((c.res.headers.get("content-type") ?? "").includes("text/html") || c.req.path === "/sw.js" || c.req.path === "/version.json") c.header("Cache-Control", "no-cache");
+  });
+  const root = path.relative(process.cwd(), config.webDist);
+  app.use("/*", serveStatic({ root }));
+  app.get("*", async (c) => c.html(await fs.promises.readFile(path.join(config.webDist, "index.html"), "utf8")));
+}
+
+const server = serve({ fetch: app.fetch, port: config.port, hostname: config.host }, (info) => {
+  console.log(`claude-ide listening on http://${config.host}:${info.port}`);
+  if (config.passwordGenerated) {
+    console.log(`Generated login password (saved to ${config.passwordFile}): ${config.password}`);
+  }
+});
+injectWebSocket(server);
+const stopDistWatcher = watchDistVersion();
+const stopPasswordWatcher = watchPassword();
+httpChannels.start();
+sessions.startReaper(config.idleReapMs);
+idecron.start();
+void sessions.resumeScheduled();
+
+for (const sig of ["SIGINT", "SIGTERM"] as const) {
+  process.on(sig, () => {
+    stopDistWatcher();
+    stopPasswordWatcher();
+    httpChannels.stop();
+    idecron.stop();
+    sessions.closeAll();
+    closeAllControl();
+    process.exit(0);
+  });
+}