@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/db.ts

@@ -0,0 +1,121 @@
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { config } from "./config.ts";
+
+/**
+ * IDE-owned state (views, authentication, HTTP registrations) lives here.
+ * The CLI remains the source of truth for conversations (see GOAL.md "CLI 是唯一的真相源").
+ * Session content, titles, tags and fork origin are read from the CLI's own files.
+ */
+export const db = new DatabaseSync(path.join(config.dataDir, "ide.sqlite"));
+
+db.exec(`PRAGMA journal_mode = WAL;`);
+
+const migrations: string[] = [
+  `CREATE TABLE auth_tokens (
+     token TEXT PRIMARY KEY,
+     created_at INTEGER NOT NULL,
+     last_seen_at INTEGER NOT NULL
+   );
+   CREATE TABLE projects (
+     path TEXT PRIMARY KEY,
+     added_at INTEGER NOT NULL,
+     sort_order INTEGER NOT NULL DEFAULT 0
+   );
+   CREATE TABLE session_view (
+     session_id TEXT PRIMARY KEY,
+     project_path TEXT NOT NULL,
+     pinned INTEGER NOT NULL DEFAULT 0,
+     archived INTEGER NOT NULL DEFAULT 0,
+     btw_parent TEXT
+   );`,
+  // A conversation rewind waiting for the next message (applied with resumeSessionAt).
+  `ALTER TABLE session_view ADD COLUMN rewind_anchor TEXT;
+   ALTER TABLE session_view ADD COLUMN rewind_text TEXT;`,
+  // /btw: the side question and the uuid of the prompt that asked it in the forked session.
+  `ALTER TABLE session_view ADD COLUMN btw_question TEXT;
+   ALTER TABLE session_view ADD COLUMN btw_prompt_uuid TEXT;`,
+  // Web Push subscriptions, one per device, with per-kind switches (server/push.ts).
+  `CREATE TABLE push_subscriptions (
+     id TEXT PRIMARY KEY,
+     endpoint TEXT NOT NULL UNIQUE,
+     p256dh TEXT NOT NULL,
+     auth TEXT NOT NULL,
+     device TEXT,
+     user_agent TEXT,
+     created_at INTEGER NOT NULL,
+     last_success_at INTEGER,
+     notify_done INTEGER NOT NULL DEFAULT 1,
+     notify_attention INTEGER NOT NULL DEFAULT 1,
+     notify_error INTEGER NOT NULL DEFAULT 1
+   );`,
+];
+
+migrations.push(`ALTER TABLE session_view ADD COLUMN rewind_id TEXT;`);
+migrations.push(`
+  CREATE TABLE http_sources (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    url TEXT NOT NULL,
+    headers_json TEXT NOT NULL DEFAULT '{}',
+    timeout_ms INTEGER NOT NULL DEFAULT 120000
+  );
+  CREATE TABLE session_http_bindings (
+    id TEXT PRIMARY KEY,
+    session_id TEXT NOT NULL,
+    source_id TEXT NOT NULL,
+    direction TEXT NOT NULL CHECK(direction IN ('subscribe', 'push')),
+    active INTEGER NOT NULL DEFAULT 0,
+    activated_at INTEGER,
+    inactive_reason TEXT,
+    created_at INTEGER NOT NULL,
+    UNIQUE(session_id, source_id, direction)
+  );
+  CREATE INDEX http_bindings_session ON session_http_bindings(session_id);
+  CREATE INDEX http_bindings_active ON session_http_bindings(active, activated_at);
+`);
+migrations.push(`ALTER TABLE http_sources ADD COLUMN extra_body_json TEXT NOT NULL DEFAULT '{}';`);
+migrations.push(`ALTER TABLE http_sources ADD COLUMN subscribe_method TEXT NOT NULL DEFAULT 'GET' CHECK(subscribe_method IN ('GET', 'POST'));`);
+migrations.push(`
+  ALTER TABLE http_sources ADD COLUMN kind TEXT NOT NULL DEFAULT 'http' CHECK(kind IN ('http', 'brain-api'));
+  ALTER TABLE http_sources ADD COLUMN brain_id TEXT;
+`);
+migrations.push(`ALTER TABLE session_view ADD COLUMN ask_questions_enabled INTEGER NOT NULL DEFAULT 1 CHECK(ask_questions_enabled IN (0, 1));`);
+migrations.push(`ALTER TABLE http_sources ADD COLUMN brain_voice TEXT;`);
+migrations.push(`ALTER TABLE session_http_bindings ADD COLUMN brain_id TEXT;
+  ALTER TABLE session_http_bindings ADD COLUMN brain_voice TEXT;`);
+migrations.push(`ALTER TABLE session_view ADD COLUMN write_enabled INTEGER NOT NULL DEFAULT 1 CHECK(write_enabled IN (0, 1));
+  UPDATE session_view SET write_enabled = 0 WHERE btw_parent IS NOT NULL;`);
+migrations.push(`ALTER TABLE session_view ADD COLUMN btw_goal_isolated INTEGER NOT NULL DEFAULT 0 CHECK(btw_goal_isolated IN (0, 1));`);
+migrations.push(`ALTER TABLE session_view ADD COLUMN btw_goal_isolation_uuid TEXT;`);
+
+// A stable verifier binds persisted login tokens to the effective password.
+// auth.ts performs the first initialization and legacy-token revocation atomically.
+migrations.push(`CREATE TABLE auth_credential (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  salt TEXT NOT NULL,
+  verifier TEXT NOT NULL
+);`);
+
+// Aliases belong to the naming session, like a private address book.
+migrations.push(`CREATE TABLE session_aliases (
+  owner_session_id TEXT NOT NULL,
+  target_session_id TEXT NOT NULL,
+  alias TEXT NOT NULL,
+  PRIMARY KEY (owner_session_id, target_session_id),
+  UNIQUE (owner_session_id, alias)
+);
+CREATE INDEX session_aliases_target ON session_aliases(target_session_id);`);
+
+const { user_version: current } = db.prepare("PRAGMA user_version").get() as { user_version: number };
+for (let v = current; v < migrations.length; v++) {
+  db.exec("BEGIN");
+  try {
+    db.exec(migrations[v]!);
+    db.exec(`PRAGMA user_version = ${v + 1}`);
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}

package/server/directories.test.ts

@@ -0,0 +1,180 @@
+import { test, after, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import type { DirectoryListing } from "../shared/directories.ts";
+import { channelFixture } from "./http-channel-test-fixture.ts";
+
+// Set isolated DB/config paths before importing routes (fsutil imports sessions).
+const fixture = await channelFixture();
+const { registerDirectoryRoutes } = await import("./directories.ts");
+registerDirectoryRoutes(fixture.app);
+after(() => fixture.close());
+
+let root: string;
+beforeEach(async () => {
+  root = await fs.mkdtemp(path.join(fixture.tmp, "directories-"));
+  await Promise.all([
+    fs.mkdir(path.join(root, "project")),
+    fs.mkdir(path.join(root, "project-other")),
+    fs.mkdir(path.join(root, "unrelated")),
+    fs.mkdir(path.join(root, ".private")),
+    fs.writeFile(path.join(root, "project.txt"), "file"),
+  ]);
+  await fs.mkdir(path.join(root, "project", "child"));
+});
+
+function request(input: string, options: { complete?: boolean; hidden?: boolean } = {}) {
+  const query = new URLSearchParams({ path: input });
+  if (options.complete !== false) query.set("complete", "1");
+  if (options.hidden) query.set("hidden", "1");
+  return fixture.app.request(`/api/directories?${query}`);
+}
+
+async function listing(input: string, options?: { complete?: boolean; hidden?: boolean }): Promise<DirectoryListing> {
+  const response = await request(input, options);
+  assert.equal(response.status, 200, await response.clone().text());
+  return response.json();
+}
+
+const names = (result: DirectoryListing) => result.entries.map((entry) => entry.name).sort();
+
+test("an unfinished absolute path returns matching directories and files from its existing parent", async () => {
+  const input = path.join(root, "proj");
+  const result = await listing(input);
+  assert.equal(result.path, root);
+  assert.equal(result.requestedPath, input);
+  assert.equal(result.requestedType, "missing");
+  assert.equal(result.prefix, "proj");
+  assert.deepEqual(result.entries, [
+    { name: "project", path: path.join(root, "project"), type: "dir" },
+    { name: "project-other", path: path.join(root, "project-other"), type: "dir" },
+    { name: "project.txt", path: path.join(root, "project.txt"), type: "file" },
+  ]);
+});
+
+test("a complete directory name remains a prefix until a trailing slash is entered", async () => {
+  const input = path.join(root, "project");
+  const result = await listing(input);
+  assert.equal(result.path, root);
+  assert.equal(result.requestedType, "dir");
+  assert.equal(result.prefix, "project");
+  assert.deepEqual(names(result), ["project", "project-other", "project.txt"]);
+
+  const inside = await listing(`${input}/`);
+  assert.equal(inside.path, input);
+  assert.equal(inside.requestedPath, input);
+  assert.equal(inside.requestedType, "dir");
+  assert.equal(inside.prefix, "");
+  assert.deepEqual(inside.entries, [{ name: "child", path: path.join(input, "child"), type: "dir" }]);
+});
+
+test("multiple nonexistent components use the nearest existing directory and first unfinished component", async () => {
+  for (const suffix of ["", "/"]) {
+    const input = path.join(root, "proj", "missing", "leaf");
+    const result = await listing(input + suffix);
+    assert.equal(result.path, root);
+    assert.equal(result.requestedPath, input);
+    assert.equal(result.requestedType, "missing");
+    assert.equal(result.prefix, "proj");
+    assert.deepEqual(names(result), ["project", "project-other", "project.txt"]);
+  }
+  const nested = await listing(path.join(root, "project", "chi", "missing"));
+  assert.equal(nested.path, path.join(root, "project"));
+  assert.equal(nested.prefix, "chi");
+  assert.deepEqual(names(nested), ["child"]);
+});
+
+test("an unmatched prefix returns an empty list without losing the typed creation target", async () => {
+  const input = path.join(root, "new", "nested");
+  const result = await listing(input);
+  assert.equal(result.path, root);
+  assert.equal(result.requestedPath, input);
+  assert.equal(result.requestedType, "missing");
+  assert.equal(result.prefix, "new");
+  assert.deepEqual(result.entries, []);
+});
+
+test("files are identified as files and never browsed as directories, including with trailing slash", async () => {
+  const input = path.join(root, "project.txt");
+  for (const suffix of ["", "/"]) {
+    const result = await listing(input + suffix);
+    assert.equal(result.path, root);
+    assert.equal(result.requestedType, "file");
+    assert.deepEqual(result.entries, [{ name: "project.txt", path: input, type: "file" }]);
+  }
+  const blocked = await listing(path.join(input, "missing", "child"));
+  assert.equal(blocked.path, root);
+  assert.equal(blocked.requestedType, "missing");
+  assert.equal(blocked.prefix, "project.txt");
+  assert.deepEqual(blocked.entries, [{ name: "project.txt", path: input, type: "file" }]);
+});
+
+test("completion is case insensitive and explicitly typed dot prefixes reveal hidden entries", async () => {
+  assert.deepEqual(names(await listing(path.join(root, "PROJ"))), ["project", "project-other", "project.txt"]);
+  assert.deepEqual(names(await listing(path.join(root, ".pri"))), [".private"]);
+  assert.ok(!names(await listing(`${root}/`)).includes(".private"));
+  assert.ok(names(await listing(`${root}/`, { hidden: true })).includes(".private"));
+});
+
+test("completion classifies symlink targets and omits broken symlinks", async () => {
+  await fs.symlink(path.join(root, "project"), path.join(root, "link-dir"));
+  await fs.symlink(path.join(root, "project.txt"), path.join(root, "link-file"));
+  await fs.symlink(path.join(root, "absent"), path.join(root, "link-broken"));
+  const result = await listing(path.join(root, "link-"));
+  assert.deepEqual(result.entries, [
+    { name: "link-dir", path: path.join(root, "link-dir"), type: "dir" },
+    { name: "link-file", path: path.join(root, "link-file"), type: "file" },
+  ]);
+});
+
+test("the default endpoint retains its directory-only response and missing/file error behavior", async () => {
+  await fs.symlink(path.join(root, "project"), path.join(root, "link-dir"));
+  await fs.symlink(path.join(root, "project.txt"), path.join(root, "link-file"));
+  const result = await listing(root, { complete: false });
+  assert.deepEqual(Object.keys(result).sort(), ["entries", "home", "parent", "path", "truncated"]);
+  assert.equal(result.parent, path.dirname(root));
+  assert.equal(result.home, os.homedir());
+  assert.equal(result.truncated, false);
+  assert.deepEqual(result.entries, ["link-dir", "project", "project-other", "unrelated"].map((name) => ({ name, path: path.join(root, name) })));
+  assert.ok(names(await listing(root, { complete: false, hidden: true })).includes(".private"));
+  assert.equal((await request(path.join(root, "proj"), { complete: false })).status, 404);
+  assert.equal((await request(path.join(root, "project.txt"), { complete: false })).status, 400);
+});
+
+test("recursive directory creation remains available for the completion target", async () => {
+  const input = path.join(root, "new", "nested");
+  const completion = await listing(input);
+  const response = await fixture.app.request("/api/directories", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ path: completion.requestedPath }),
+  });
+  assert.equal(response.status, 201);
+  const result = await response.json() as DirectoryListing;
+  assert.equal(result.path, input);
+  assert.deepEqual(result.entries, []);
+  assert.equal(result.requestedPath, undefined);
+  assert.ok((await fs.stat(input)).isDirectory());
+  assert.equal((await listing(`${input}/`)).requestedType, "dir");
+});
+
+test("creating over a file or through a file fails without changing that file", async () => {
+  for (const [input, status] of [[path.join(root, "project.txt"), 409], [path.join(root, "project.txt", "child"), 400]] as const) {
+    const response = await fixture.app.request("/api/directories", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ path: input }),
+    });
+    assert.equal(response.status, status);
+  }
+  assert.equal(await fs.readFile(path.join(root, "project.txt"), "utf8"), "file");
+});
+
+test("both modes reject relative and NUL-containing paths", async () => {
+  for (const complete of [true, false]) {
+    assert.equal((await request("relative/path", { complete })).status, 400);
+    assert.equal((await request(`${root}/bad\0path`, { complete })).status, 400);
+  }
+});

package/server/directories.ts

@@ -0,0 +1,87 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import type { Hono } from "hono";
+import type { DirectoryListing } from "../shared/directories.ts";
+import { FsHttpError, route } from "./fsutil.ts";
+
+/** Registered after requireAuth: selecting a new project must also browse unregistered directories. */
+export function registerDirectoryRoutes(app: Hono) {
+  app.get("/api/directories", route(async (c) => c.json(c.req.query("complete") === "1"
+    ? await completeDirectory(c.req.query("path"), c.req.query("hidden") === "1")
+    : await listDirectories(c.req.query("path"), c.req.query("hidden") === "1"))));
+  app.post("/api/directories", route(async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (typeof body?.path !== "string" || !body.path.trim()) throw new FsHttpError(400, "请填写要创建的目录路径");
+    const directory = resolveDirectory(body.path);
+    try {
+      await fs.mkdir(directory, { recursive: true });
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException).code;
+      if (code === "EACCES" || code === "EPERM" || code === "EROFS") throw new FsHttpError(403, "没有权限创建这个目录");
+      if (code === "EEXIST") throw new FsHttpError(409, "这个路径已存在且不是目录");
+      if (code === "ENOTDIR") throw new FsHttpError(400, "路径中包含文件，无法创建目录");
+      if (code === "ENAMETOOLONG") throw new FsHttpError(400, "目录路径过长");
+      throw err;
+    }
+    return c.json(await listDirectories(directory, c.req.query("hidden") === "1"), 201);
+  }));
+}
+
+function resolveDirectory(input: string | undefined) {
+  const home = os.homedir();
+  const raw = input || home;
+  if (raw.includes("\0")) throw new FsHttpError(400, "目录路径无效");
+  const expanded = raw === "~" ? home : raw.startsWith("~/") ? path.join(home, raw.slice(2)) : raw;
+  if (!path.isAbsolute(expanded)) throw new FsHttpError(400, "请填写绝对路径");
+  return path.resolve(expanded);
+}
+
+async function completeDirectory(input: string | undefined, hidden: boolean): Promise<DirectoryListing> {
+  const requestedPath = resolveDirectory(input);
+  const statPath = (directory: string) => fs.stat(directory).catch((error: NodeJS.ErrnoException) => {
+    if (error.code === "ENOENT" || error.code === "ENOTDIR") return undefined;
+    if (error.code === "EACCES" || error.code === "EPERM") throw new FsHttpError(403, "没有权限读取这个目录");
+    throw error;
+  });
+  const target = await statPath(requestedPath);
+  const requestedType = !target ? "missing" : target.isDirectory() ? "dir" : "file";
+  const exact = !input || input === "~" || /[\\/]$/.test(input) || path.dirname(requestedPath) === requestedPath;
+  let parent = exact && target?.isDirectory() ? requestedPath : path.dirname(requestedPath);
+  // Only climb missing/non-directory components. Permission errors must remain
+  // errors, rather than silently suggesting a different location.
+  while (true) {
+    const stat = await statPath(parent);
+    if (stat?.isDirectory() || path.dirname(parent) === parent) break;
+    parent = path.dirname(parent);
+  }
+  const prefix = parent === requestedPath ? "" : path.relative(parent, requestedPath).split(path.sep)[0]!;
+  const listing = await listDirectories(parent, hidden || prefix.startsWith("."), { prefix });
+  return { ...listing, requestedPath, requestedType, prefix };
+}
+
+async function listDirectories(input: string | undefined, hidden: boolean, completion?: { prefix: string }): Promise<DirectoryListing> {
+  const cwd = resolveDirectory(input);
+  try {
+    const dirents = await fs.readdir(cwd, { withFileTypes: true });
+    const candidates = dirents
+      .filter((entry) => (hidden || !entry.name.startsWith(".")) && (completion || entry.isDirectory() || entry.isSymbolicLink())
+        && (!completion || entry.name.toLocaleLowerCase().startsWith(completion.prefix.toLocaleLowerCase())))
+      .sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" }));
+    const entries = await Promise.all(candidates.slice(0, 5000).map(async (entry) => {
+      const child = path.join(cwd, entry.name);
+      const stat = entry.isSymbolicLink() ? await fs.stat(child).catch(() => undefined) : undefined;
+      const directory = entry.isDirectory() || !!stat?.isDirectory();
+      if (!directory && (!completion || !entry.isFile() && !stat?.isFile())) return undefined;
+      return { name: entry.name, path: child, ...(completion ? { type: directory ? "dir" as const : "file" as const } : {}) };
+    }));
+    const parent = path.dirname(cwd);
+    return { path: cwd, parent: parent === cwd ? null : parent, home: os.homedir(), entries: entries.filter((entry) => entry !== undefined), truncated: candidates.length > 5000 };
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "EACCES" || code === "EPERM") throw new FsHttpError(403, "没有权限读取这个目录");
+    if (code === "ENOENT") throw new FsHttpError(404, "目录不存在");
+    if (code === "ENOTDIR") throw new FsHttpError(400, "这个路径不是目录");
+    throw err;
+  }
+}

package/server/dist-version.ts

@@ -0,0 +1,69 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { config } from "./config.ts";
+
+type Manifest = { version: string; files: { path: string; size: number }[] };
+let validatedVersion: string | undefined;
+const listeners = new Set<(version: string) => void>();
+
+export function onDistVersion(fn: (version: string) => void) {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+
+/** The index and all emitted assets must match the deployment manifest before it is usable. */
+export async function deployedDistVersion(): Promise<string | undefined> {
+  if (!config.production) return;
+  try {
+    const manifest = JSON.parse(await fs.readFile(path.join(config.webDist, "version.json"), "utf8")) as Manifest;
+    if (typeof manifest.version !== "string" || !manifest.version || !Array.isArray(manifest.files) || !manifest.files.length) return;
+    const html = await fs.readFile(path.join(config.webDist, "index.html"), "utf8");
+    const htmlVersion = /<meta\b[^>]*\bname=["']cide-build["'][^>]*\bcontent=["']([^"']+)["']/.exec(html)?.[1];
+    if (htmlVersion !== manifest.version) return;
+    if (manifest.version !== validatedVersion) {
+      const ready = await Promise.all(manifest.files.map(async (file) => {
+        if (typeof file.path !== "string" || path.isAbsolute(file.path) || file.path.split(/[\\/]/).includes("..") || !Number.isFinite(file.size)) return false;
+        const stat = await fs.stat(path.join(config.webDist, file.path)).catch(() => undefined);
+        return stat?.isFile() && stat.size === file.size;
+      }));
+      if (!ready.every(Boolean)) return;
+      validatedVersion = manifest.version;
+    }
+    return manifest.version;
+  } catch {
+    // Missing or partly-written files during a build/deploy are expected.
+    return undefined;
+  }
+}
+
+/** Polling survives rsync replacing files or the entire dist directory. */
+export function watchDistVersion(): () => void {
+  if (!config.production) return () => {};
+  let checking = false;
+  let stopped = false;
+  let published: string | undefined;
+  let candidate: string | undefined;
+  let candidateSince = 0;
+  const check = async () => {
+    if (checking || stopped) return;
+    checking = true;
+    try {
+      const version = await deployedDistVersion();
+      if (!version || stopped) return;
+      if (version !== candidate) {
+        candidate = version;
+        candidateSince = Date.now();
+      }
+      // Let a deployment burst settle before suggesting a refresh to an already open page.
+      if (published && version !== published && Date.now() - candidateSince < 1500) return;
+      published = version;
+      for (const listener of listeners) listener(version);
+    } finally {
+      checking = false;
+    }
+  };
+  void check();
+  const timer = setInterval(() => void check(), 2000);
+  timer.unref();
+  return () => { stopped = true; clearInterval(timer); };
+}

package/server/durable-tasks.ts

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+
+/**
+ * A durable scheduled task written by the CLI to `<cwd>/.claude/scheduled_tasks.json`.
+ * This file is CLI-owned; parse defensively and never write to it from here.
+ */
+export type DurableTask = {
+  id: string;
+  cron: string;
+  prompt: string;
+  recurring: boolean;
+  createdBySessionId?: string;
+  createdAt?: number;
+  lastFiredAt?: number;
+};
+
+function task(value: unknown): DurableTask | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const t = value as Record<string, unknown>;
+  if (typeof t.id !== "string" || typeof t.cron !== "string" || typeof t.prompt !== "string") return undefined;
+  return {
+    id: t.id,
+    cron: t.cron,
+    prompt: t.prompt,
+    recurring: t.recurring === true,
+    ...(typeof t.createdBySessionId === "string" ? { createdBySessionId: t.createdBySessionId } : {}),
+    ...(typeof t.createdAt === "number" ? { createdAt: t.createdAt } : {}),
+    ...(typeof t.lastFiredAt === "number" ? { lastFiredAt: t.lastFiredAt } : {}),
+  };
+}
+
+/** Read the durable task file for a session's working directory. Missing or malformed files mean no tasks. */
+export function durableTasks(cwd: string): DurableTask[] {
+  const file = path.join(cwd, ".claude", "scheduled_tasks.json");
+  let raw: string;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw) as { tasks?: unknown };
+    if (!Array.isArray(parsed.tasks)) return [];
+    return parsed.tasks.flatMap((t) => {
+      const parsedTask = task(t);
+      return parsedTask ? [parsedTask] : [];
+    });
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Durable tasks belonging to one session. Tasks without a creator predate the ownership field;
+ * show those too rather than hiding them. Other sessions' tasks are skipped: the panel is per
+ * session, and the CLI will run them from whichever process owns the scheduler lock.
+ */
+export function durableTasksForSession(cwd: string, sessionId: string): DurableTask[] {
+  return durableTasks(cwd).filter((t) => !t.createdBySessionId || t.createdBySessionId === sessionId);
+}

package/server/file-transfers.ts

@@ -0,0 +1,79 @@
+import fs from "node:fs/promises";
+import { constants } from "node:fs";
+import path from "node:path";
+import { Readable } from "node:stream";
+import type { Hono } from "hono";
+import { bodyLimit } from "hono/body-limit";
+import { MAX_UPLOAD_BYTES, MAX_UPLOAD_FILES, type UploadResult } from "../shared/files.ts";
+import { FsHttpError, projectRoot, resolveSafe, route } from "./fsutil.ts";
+
+export function registerFileTransferRoutes(app: Hono) {
+  app.get("/api/projects/:pid/file/download", route(async (c) => {
+    const root = projectRoot(c), target = await resolveSafe(root, c.req.query("path"));
+    const real = await resolveSafe(root, await fs.realpath(target.abs));
+    const handle = await fs.open(real.abs, constants.O_RDONLY | constants.O_NONBLOCK | constants.O_NOFOLLOW);
+    try {
+      const stat = await handle.stat();
+      if (!stat.isFile()) throw new FsHttpError(400, "只能下载普通文件");
+      const filename = encodeURIComponent(path.basename(target.abs)).replace(/['()*]/g, (character) => `%${character.charCodeAt(0).toString(16)}`);
+      return new Response(Readable.toWeb(handle.createReadStream()) as ReadableStream<Uint8Array>, { headers: {
+        "content-type": "application/octet-stream", "content-length": String(stat.size),
+        "content-disposition": `attachment; filename*=UTF-8''${filename}`,
+        "cache-control": "no-store", "x-content-type-options": "nosniff",
+      } });
+    } catch (error) { await handle.close(); throw error; }
+  }));
+  app.post("/api/projects/:pid/files/upload", bodyLimit({
+    maxSize: MAX_UPLOAD_BYTES + 1024 * 1024,
+    onError: (c) => c.json({ error: "单次上传最多 50 MiB" }, 413),
+  }), route(async (c) => {
+    const root = projectRoot(c), selected = await resolveSafe(root, c.req.query("path"));
+    const target = await resolveSafe(root, await fs.realpath(selected.abs));
+    if (!(await fs.stat(target.abs)).isDirectory()) throw new FsHttpError(400, "上传目标不是文件夹");
+    let form: FormData;
+    try { form = await c.req.formData(); } catch { throw new FsHttpError(400, "上传格式无效"); }
+    const files = form.getAll("files");
+    if (!files.length || files.length > MAX_UPLOAD_FILES || !files.every((file) => file instanceof File)) throw new FsHttpError(400, "请选择 1 至 100 个文件");
+    if (files.reduce((bytes, file) => bytes + file.size, 0) > MAX_UPLOAD_BYTES) throw new FsHttpError(413, "单次上传最多 50 MiB");
+    const names = new Set<string>();
+    for (const file of files) {
+      if (!file.name || /[\/\\\0]/.test(file.name) || file.name === "." || file.name === ".." || names.has(file.name)) throw new FsHttpError(400, "文件名无效或重复");
+      names.add(file.name);
+    }
+    const overwrite = new Set(form.getAll("overwrite").filter((name): name is string => typeof name === "string" && names.has(name)));
+    const result: UploadResult = { files: [], conflicts: [] };
+    const planned = await Promise.all(files.map(async (file) => {
+      const dest = await resolveSafe(root, path.join(target.rel, file.name), { mustExist: false });
+      const stat = await fs.lstat(dest.abs).catch((error: NodeJS.ErrnoException) => { if (error.code === "ENOENT") return undefined; throw error; });
+      if (stat && !stat.isFile() && !stat.isSymbolicLink()) throw new FsHttpError(409, `“${file.name}”不是可覆盖的文件`);
+      if (stat && !overwrite.has(file.name)) result.conflicts.push(file.name);
+      return { file, dest };
+    }));
+    if (result.conflicts.length) return c.json(result, 409);
+    // Stage complete files in the destination filesystem, then publish atomically.
+    const staging = await fs.mkdtemp(path.join(target.abs, ".claude-ide-upload-"));
+    try {
+      for (const [index, item] of planned.entries()) await fs.writeFile(path.join(staging, String(index)), new Uint8Array(await item.file.arrayBuffer()), { flag: "wx" });
+      for (const [index, item] of planned.entries()) {
+        const destination = await resolveSafe(root, item.dest.rel, { mustExist: false });
+        const staged = path.join(staging, String(index));
+        if (overwrite.has(item.file.name)) {
+          const existing = await fs.lstat(destination.abs).catch((error: NodeJS.ErrnoException) => { if (error.code === "ENOENT") return undefined; throw error; });
+          // Apply the target's ordinary permissions before publishing, so a
+          // private file never becomes temporarily readable with the umask default.
+          if (existing?.isFile()) await fs.chmod(staged, existing.mode & 0o777);
+          await fs.rename(staged, destination.abs);
+        }
+        else {
+          try { await fs.link(staged, destination.abs); }
+          catch (error) {
+            if ((error as NodeJS.ErrnoException).code === "EEXIST") { result.conflicts.push(item.file.name); continue; }
+            throw error;
+          }
+        }
+        result.files.push(path.posix.join(selected.rel, item.file.name));
+      }
+      return c.json(result, result.conflicts.length ? 409 : 200);
+    } finally { await fs.rm(staging, { recursive: true, force: true }); }
+  }));
+}