@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/session-messaging.test.ts

@@ -0,0 +1,297 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+
+const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "cide-peer-")));
+process.env.CLAUDE_IDE_DATA_DIR = path.join(root, "data");
+process.env.CLAUDE_CONFIG_DIR = path.join(root, "claude");
+process.env.CLAUDE_IDE_PASSWORD = "peer-test";
+const { sessionMessaging, configureSessionMessaging, beginSessionDeletion } = await import("./session-messaging.ts");
+const aliases = await import("./session-aliases.ts");
+const { db } = await import("./db.ts");
+const { sessions, createDraftSession, removeSession, resolveMessagingSession } = await import("./sessions.ts");
+
+function deferred() {
+  let resolve!: () => void;
+  const promise = new Promise<void>((r) => { resolve = r; });
+  return { promise, resolve };
+}
+
+function fixture() {
+  const a = crypto.randomUUID(), b = crypto.randomUUID(), c = crypto.randomUUID();
+  const targets = new Map<string, { sessionId: string; projectPath: string; cwd: string }>([a, b, c].map((id) => [id, { sessionId: id, projectPath: `/project/${id}`, cwd: `/project/${id}` }]));
+  const deliveries: { id: string; text: string }[] = [];
+  const created: string[] = [];
+  let writable = true;
+  const deps = {
+    resolveExistingSession: async (id: string) => targets.get(id),
+    assertAllowed: () => { if (!writable) throw new Error("readonly"); },
+    getOrCreate: async (id: string) => {
+      created.push(id);
+      return {
+        cwd: targets.get(id)!.cwd,
+        sendPeerText: async (_uuid: string, text: string, active: () => boolean) => {
+          if (!active()) return false;
+          deliveries.push({ id, text });
+          return true;
+        },
+      };
+    },
+  };
+  configureSessionMessaging(deps);
+  return { a, b, c, targets, deliveries, created, deps, readonly: () => { writable = false; } };
+}
+
+test("send resolves caller's alias and marks source using receiver's independent address book", async () => {
+  const f = fixture();
+  await sessionMessaging.setAlias(f.a, f.b, "reviewer");
+  await sessionMessaging.setAlias(f.b, f.a, "planner");
+  await sessionMessaging.setAlias(f.c, f.a, "reviewer");
+  assert.deepEqual(await sessionMessaging.send(f.a, "reviewer", "/btw literal text"), { sessionId: f.b, status: "queued" });
+  assert.deepEqual(f.created, [f.b]);
+  assert.equal(f.deliveries[0]!.text, `Message from session ${f.a}\nSource alias: "planner"\n\n/btw literal text`);
+  await sessionMessaging.removeAlias(f.b, "planner");
+  await sessionMessaging.send(f.a, f.b.toUpperCase(), "second");
+  assert.match(f.deliveries[1]!.text, /Source alias: ""/);
+  await assert.rejects(sessionMessaging.send(f.a, f.a.toUpperCase(), "self"), /自身/);
+});
+
+test("unknown targets never create sessions; malformed and oversized messages are rejected", async () => {
+  const f = fixture();
+  await assert.rejects(sessionMessaging.send(f.a, crypto.randomUUID(), "missing"), /不存在/);
+  await assert.rejects(sessionMessaging.send(f.a, "unknown-alias", "missing"), /不存在/);
+  await assert.rejects(sessionMessaging.send(f.a, f.b, " "), /不能为空/);
+  await assert.rejects(sessionMessaging.send(f.a, f.b, "a".repeat(262145)), /256/);
+  assert.equal(f.created.length, 0);
+});
+
+test("accepted alias address is frozen while lookups run", async () => {
+  const f = fixture();
+  aliases.setAlias(f.a, f.b, "peer");
+  const gate = deferred();
+  configureSessionMessaging({ ...f.deps, resolveExistingSession: async (id) => { await gate.promise; return f.targets.get(id); } });
+  const sending = sessionMessaging.send(f.a, "peer", "frozen");
+  aliases.removeAlias(f.a, "peer");
+  aliases.setAlias(f.a, f.c, "peer");
+  gate.resolve();
+  await sending;
+  assert.equal(f.deliveries[0]!.id, f.b);
+});
+
+test("deletion invalidates in-flight work even if deletion finishes before lookup returns", async () => {
+  const f = fixture();
+  const gate = deferred();
+  configureSessionMessaging({ ...f.deps, resolveExistingSession: async (id) => { await gate.promise; return f.targets.get(id); } });
+  const sending = sessionMessaging.send(f.a, f.b, "stale");
+  const deleted = beginSessionDeletion(f.b);
+  deleted();
+  gate.resolve();
+  await assert.rejects(sending, /删除/);
+  assert.equal(f.created.length, 0);
+});
+
+test("readonly change during target lookup prevents both alias mutation and delivery", async () => {
+  const f = fixture();
+  const gate = deferred();
+  configureSessionMessaging({ ...f.deps, resolveExistingSession: async (id) => { await gate.promise; return f.targets.get(id); } });
+  const alias = sessionMessaging.setAlias(f.a, f.b, "blocked");
+  const sending = sessionMessaging.send(f.a, f.b, "blocked");
+  f.readonly();
+  gate.resolve();
+  await assert.rejects(alias, /readonly/);
+  await assert.rejects(sending, /readonly/);
+  assert.equal(aliases.aliasTarget(f.a, "blocked"), undefined);
+  assert.equal(f.created.length, 0);
+});
+
+test("a live session started in another existing directory is rejected after startup", async () => {
+  const f = fixture();
+  const destination = fs.mkdtempSync(path.join(root, "destination-"));
+  const moved = fs.mkdtempSync(path.join(root, "moved-"));
+  configureSessionMessaging({
+    ...f.deps,
+    resolveExistingSession: async (id) => (id === f.b ? { sessionId: f.b, projectPath: destination, cwd: destination } : f.targets.get(id)),
+    getOrCreate: async () => ({ cwd: moved, sendPeerText: async () => true }),
+  });
+  await assert.rejects(sessionMessaging.send(f.a, f.b, "wrong directory"), /位置发生变化/);
+});
+
+test("a project registered through a symlink can receive messages from a transcript that records the real path", async () => {
+  const real = fs.mkdtempSync(path.join(root, "real-"));
+  const link = path.join(root, "link-");
+  fs.symlinkSync(real, link);
+  db.prepare("INSERT INTO projects(path, added_at) VALUES (?, ?)").run(link, Date.now());
+  const receiver = crypto.randomUUID();
+  db.prepare("INSERT INTO session_view (session_id, project_path) VALUES (?, ?)").run(receiver, link);
+  const sender = createDraftSession(real);
+  // The CLI writes the resolved cwd (not the symlink the project was registered with).
+  const dir = path.join(process.env.CLAUDE_CONFIG_DIR!, "projects", real.replace(/[^a-zA-Z0-9]/g, "-"));
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `${receiver}.jsonl`), JSON.stringify({ type: "user", sessionId: receiver, cwd: real, uuid: crypto.randomUUID(), parentUuid: null, timestamp: new Date().toISOString(), message: { role: "user", content: "symlinked project" } }) + "\n");
+  const deliveries: string[] = [];
+  configureSessionMessaging({
+    resolveExistingSession: resolveMessagingSession,
+    getOrCreate: async (id, project, stillActive) => {
+      const live = await sessions.getOrCreate(id, project, stillActive);
+      return {
+        cwd: live.cwd,
+        sendPeerText: async (_uuid: string, text: string, active: () => boolean) => {
+          if (!active()) return false;
+          deliveries.push(text);
+          return true;
+        },
+      };
+    },
+    assertAllowed: () => {},
+  });
+  try {
+    assert.deepEqual(await resolveMessagingSession(receiver), { sessionId: receiver, projectPath: link, cwd: real });
+    // The live wrapper runs in the registered (symlink) project path, so the two
+    // spellings name the same directory and must not be treated as a move.
+    assert.equal((await sessions.getOrCreate(receiver, link)).cwd, link);
+    assert.deepEqual(await sessionMessaging.send(sender, receiver, "through the link"), { sessionId: receiver, status: "queued" });
+    assert.equal(deliveries.length, 1);
+  } finally {
+    await sessions.drop(receiver);
+  }
+});
+
+test("filesystem identity keeps the final target guard from reporting a move between two spellings of one project", async () => {
+  const f = fixture();
+  const real = fs.mkdtempSync(path.join(root, "target-"));
+  const link = path.join(root, "target-link-");
+  fs.symlinkSync(real, link);
+  let lookups = 0;
+  configureSessionMessaging({
+    ...f.deps,
+    resolveExistingSession: async (id) => {
+      if (id !== f.b) return f.targets.get(id);
+      lookups += 1;
+      // The first lookup resolves through the registered project path; the re-check
+      // reports the project's real path. Both name the same directory.
+      return { sessionId: f.b, projectPath: lookups === 1 ? link : real, cwd: real };
+    },
+    getOrCreate: async () => ({ cwd: real, sendPeerText: async () => true }),
+  });
+  assert.deepEqual(await sessionMessaging.send(f.a, f.b, "canonical"), { sessionId: f.b, status: "queued" });
+});
+
+test("a move to another existing directory is still rejected", async () => {
+  const f = fixture();
+  const destination = fs.mkdtempSync(path.join(root, "destination-"));
+  // Simulates /cd or worktree removal racing the live-session startup.
+  const moved = fs.mkdtempSync(path.join(root, "moved-"));
+  configureSessionMessaging({
+    ...f.deps,
+    resolveExistingSession: async (id) => (id === f.b ? { sessionId: f.b, projectPath: destination, cwd: destination } : f.targets.get(id)),
+    getOrCreate: async () => ({ cwd: moved, sendPeerText: async () => true }),
+  });
+  await assert.rejects(sessionMessaging.send(f.a, f.b, "really moved"), /位置发生变化/);
+});
+
+test("a relative cwd containing .. names the same destination", async () => {
+  const f = fixture();
+  const real = fs.mkdtempSync(path.join(root, "relative-"));
+  fs.mkdirSync(path.join(real, "sub"));
+  const spelling = `${path.relative(process.cwd(), real)}${path.sep}sub${path.sep}..`;
+  configureSessionMessaging({
+    ...f.deps,
+    resolveExistingSession: async (id) => (id === f.b ? { sessionId: f.b, projectPath: real, cwd: real } : f.targets.get(id)),
+    getOrCreate: async () => ({ cwd: spelling, sendPeerText: async () => true }),
+  });
+  assert.deepEqual(await sessionMessaging.send(f.a, f.b, "relative"), { sessionId: f.b, status: "queued" });
+});
+
+test("missing directories compare lexically and never surface stat errors", async () => {
+  const f = fixture();
+  const gone = path.join(root, "gone", "project");
+  const spelling = `${gone}${path.sep}nested${path.sep}..`;
+  configureSessionMessaging({
+    ...f.deps,
+    resolveExistingSession: async (id) => (id === f.b ? { sessionId: f.b, projectPath: gone, cwd: gone } : f.targets.get(id)),
+    getOrCreate: async () => ({ cwd: spelling, sendPeerText: async () => true }),
+  });
+  assert.deepEqual(await sessionMessaging.send(f.a, f.b, "gone"), { sessionId: f.b, status: "queued" });
+});
+
+async function sendWithLiveCwd(f: ReturnType<typeof fixture>, project: string, liveCwd: string) {
+  configureSessionMessaging({
+    ...f.deps,
+    resolveExistingSession: async (id) => (id === f.b ? { sessionId: f.b, projectPath: project, cwd: project } : f.targets.get(id)),
+    getOrCreate: async () => ({ cwd: liveCwd, sendPeerText: async () => true }),
+  });
+  return sessionMessaging.send(f.a, f.b, "identity");
+}
+
+test("zero inodes fall back to lexical comparison instead of trusting identity", async (t) => {
+  // Windows filesystems and some network mounts report ino 0 for every entry. The mocked
+  // paths share an inode, so trusting it would wrongly accept two lexical spellings.
+  t.mock.method(fsPromises, "stat", (async () => ({ dev: 1, ino: 0 })) as unknown as typeof fsPromises.stat);
+  const real = fs.mkdtempSync(path.join(root, "zero-real-"));
+  fs.mkdirSync(path.join(real, "sub"));
+  const link = path.join(root, "zero-link-");
+  fs.symlinkSync(real, link);
+  const f = fixture();
+  await assert.rejects(sendWithLiveCwd(f, real, link), /位置发生变化/);
+  const g = fixture();
+  assert.deepEqual(await sendWithLiveCwd(g, real, `${real}${path.sep}sub${path.sep}..`), { sessionId: g.b, status: "queued" });
+});
+
+test("real resolver recognizes drafts and imported transcripts, rejects idle phantom wrappers and missing worktrees", async () => {
+  const project = fs.mkdtempSync(path.join(root, "project-"));
+  db.prepare("INSERT INTO projects(path, added_at) VALUES (?, ?)").run(project, Date.now());
+  const draft = createDraftSession(project);
+  assert.deepEqual(await resolveMessagingSession(draft), { sessionId: draft, projectPath: project, cwd: project });
+  const phantom = crypto.randomUUID();
+  await sessions.getOrCreate(phantom, project);
+  assert.equal(await resolveMessagingSession(phantom), undefined);
+  const imported = crypto.randomUUID();
+  const dir = path.join(process.env.CLAUDE_CONFIG_DIR!, "projects", project.replace(/[^a-zA-Z0-9]/g, "-"));
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `${imported}.jsonl`), JSON.stringify({ type: "user", sessionId: imported, cwd: project, uuid: crypto.randomUUID(), parentUuid: null, timestamp: new Date().toISOString(), message: { role: "user", content: "imported test session" } }) + "\n");
+  assert.deepEqual(await resolveMessagingSession(imported), { sessionId: imported, projectPath: project, cwd: project });
+  const missing = createDraftSession(project);
+  db.prepare("INSERT INTO session_cwd(session_id,cwd) VALUES (?, ?)").run(missing, path.join(project, ".claude/worktrees/deleted"));
+  await assert.rejects(resolveMessagingSession(missing), /工作目录不存在/);
+  await sessions.drop(phantom);
+});
+
+test("stopping a process retains aliases; successful session deletion removes inbound and owned mappings", async () => {
+  const project = fs.mkdtempSync(path.join(root, "deletion-"));
+  const a = createDraftSession(project), b = createDraftSession(project), c = createDraftSession(project);
+  aliases.setAlias(a, b, "b");
+  aliases.setAlias(b, c, "c");
+  await sessions.drop(b);
+  assert.equal(aliases.aliasTarget(a, "b"), b);
+  const dir = path.join(process.env.CLAUDE_CONFIG_DIR!, "projects", project.replace(/[^a-zA-Z0-9]/g, "-"));
+  fs.mkdirSync(dir, { recursive: true });
+  const transcript = path.join(dir, `${b}.jsonl`);
+  // A transcript containing only system records has no session-list summary.
+  fs.writeFileSync(transcript, JSON.stringify({ type: "system", sessionId: b, cwd: project, uuid: crypto.randomUUID(), subtype: "init" }) + "\n");
+  await removeSession(b, project);
+  assert.equal(fs.existsSync(transcript), false);
+  assert.equal(aliases.aliasTarget(a, "b"), undefined);
+  assert.deepEqual(aliases.aliasesFor(b), []);
+});
+
+test("transcript access errors do not release aliases or forget the session", async () => {
+  const project = fs.mkdtempSync(path.join(root, "unreadable-"));
+  const a = createDraftSession(project), b = createDraftSession(project);
+  aliases.setAlias(a, b, "keep");
+  const dir = path.join(process.env.CLAUDE_CONFIG_DIR!, "projects");
+  fs.mkdirSync(dir, { recursive: true });
+  // A non-directory at the project store path yields ENOTDIR. Permissive history
+  // lookup returns no record; strict deletion must retain state rather than infer absence.
+  const blocker = path.join(dir, project.replace(/[^a-zA-Z0-9]/g, "-"));
+  fs.writeFileSync(blocker, "blocked");
+  await assert.rejects(removeSession(b, project), (err: NodeJS.ErrnoException) => err.code === "ENOTDIR");
+  assert.equal(aliases.aliasTarget(a, "keep"), b);
+  assert.ok(db.prepare("SELECT session_id FROM session_view WHERE session_id = ?").get(b));
+  fs.unlinkSync(blocker);
+  await removeSession(b, project);
+  assert.equal(aliases.aliasTarget(a, "keep"), undefined);
+});

package/server/session-messaging.ts

@@ -0,0 +1,165 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { aliasForTarget, aliasTarget, removeAlias, setAlias, validateAlias, SESSION_ID_PATTERN } from "./session-aliases.ts";
+
+export type MessagingTarget = { sessionId: string; projectPath: string; cwd: string };
+type MessagingLive = { cwd: string; sendPeerText(uuid: string, text: string, stillActive: () => boolean): Promise<boolean> };
+type MessagingDependencies = {
+  resolveExistingSession(id: string): Promise<MessagingTarget | undefined>;
+  getOrCreate(id: string, projectPath: string, stillActive: () => boolean): Promise<MessagingLive>;
+  assertAllowed(sender: string, action: "send" | "alias"): void;
+};
+
+let dependencies: MessagingDependencies | undefined;
+export function configureSessionMessaging(value: MessagingDependencies) { dependencies = value; }
+
+// Only operations currently in flight occupy memory. Deletion invalidates their guards
+// before its first await, so an old lookup cannot resurrect a deleted conversation.
+const deleting = new Set<string>();
+const operations = new Map<string, Set<{ valid: boolean }>>();
+export function beginSessionDeletion(id: string): () => void {
+  if (deleting.has(id)) throw new Error("会话正在删除，请稍后重试。");
+  deleting.add(id);
+  for (const operation of operations.get(id) ?? []) operation.valid = false;
+  return () => { deleting.delete(id); };
+}
+
+function operationFor(ids: string[]) {
+  const operation = { valid: true };
+  for (const id of ids) {
+    if (deleting.has(id)) operation.valid = false;
+    const active = operations.get(id) ?? new Set();
+    active.add(operation);
+    operations.set(id, active);
+  }
+  return {
+    active: () => operation.valid && ids.every((id) => !deleting.has(id)),
+    release: () => {
+      for (const id of ids) {
+        const active = operations.get(id);
+        active?.delete(operation);
+        if (!active?.size) operations.delete(id);
+      }
+    },
+  };
+}
+
+function service() {
+  if (!dependencies) throw new Error("跨会话消息服务尚未初始化。");
+  return dependencies;
+}
+function callerId(id: string) {
+  if (!SESSION_ID_PATTERN.test(id)) throw new Error("当前会话的 Session ID 无效。");
+  return id.toLowerCase();
+}
+function targetId(sender: string, to: string) {
+  const address = to.trim();
+  const id = SESSION_ID_PATTERN.test(address) ? address.toLowerCase() : aliasTarget(sender, address);
+  if (!id) throw new Error("Alias 不存在，请使用当前会话的通讯录昵称或 Session ID。");
+  return id;
+}
+
+/**
+ * Filesystem identity of a path, following symlinks. Two spellings of one directory
+ * (symlink, `..`, case-insensitive mount, hard link, bind mount) share `dev:ino`.
+ * Missing or inaccessible paths, and filesystems that cannot report an inode, yield
+ * null so callers fall back to lexical comparison.
+ */
+async function pathIdentity(p: string): Promise<string | null> {
+  try {
+    const s = await fs.stat(p);
+    return s.ino === 0 ? null : `${s.dev}:${s.ino}`;
+  } catch {
+    return null;
+  }
+}
+
+/** Compare by filesystem identity when both sides have one, otherwise lexically. */
+function sameIdentity(aPath: string, aId: string | null, bPath: string, bId: string | null) {
+  if (aId !== null && bId !== null) return aId === bId;
+  return path.resolve(aPath) === path.resolve(bPath);
+}
+
+async function samePath(a: string, b: string) {
+  const [aId, bId] = await Promise.all([pathIdentity(a), pathIdentity(b)]);
+  return sameIdentity(a, aId, b, bId);
+}
+
+async function sameTarget(a: MessagingTarget, b: MessagingTarget | undefined) {
+  if (!b || a.sessionId !== b.sessionId) return false;
+  const [projectSame, cwdSame] = await Promise.all([samePath(a.projectPath, b.projectPath), samePath(a.cwd, b.cwd)]);
+  return projectSame && cwdSame;
+}
+
+export const sessionMessaging = {
+  async removeAlias(sender: string, alias: string): Promise<boolean> {
+    sender = callerId(sender);
+    alias = validateAlias(alias);
+    const deps = service();
+    const operation = operationFor([sender]);
+    try {
+      deps.assertAllowed(sender, "alias");
+      if (!(await deps.resolveExistingSession(sender))) throw new Error("会话不存在。");
+      if (!operation.active()) throw new Error("会话已删除或正在删除。");
+      deps.assertAllowed(sender, "alias");
+      return removeAlias(sender, alias);
+    } finally { operation.release(); }
+  },
+
+  async setAlias(sender: string, target: string, alias: string): Promise<void> {
+    sender = callerId(sender);
+    target = target.toLowerCase();
+    alias = validateAlias(alias);
+    if (!SESSION_ID_PATTERN.test(target)) throw new Error("请填写有效的目标 Session ID。");
+    const deps = service();
+    const operation = operationFor([sender, target]);
+    try {
+      deps.assertAllowed(sender, "alias");
+      const [source, destination] = await Promise.all([
+        deps.resolveExistingSession(sender), deps.resolveExistingSession(target),
+      ]);
+      if (!operation.active()) throw new Error("会话已删除或正在删除。");
+      if (!source || !destination) throw new Error("会话不存在。");
+      deps.assertAllowed(sender, "alias");
+      setAlias(sender, target, alias);
+    } finally { operation.release(); }
+  },
+
+  async send(sender: string, to: string, text: string): Promise<{ sessionId: string; status: "queued" }> {
+    sender = callerId(sender);
+    if (!text.trim()) throw new Error("消息不能为空。");
+    if (Buffer.byteLength(text, "utf8") > 256 * 1024) throw new Error("消息不能超过 256 KiB。");
+    const id = targetId(sender, to);
+    if (id === sender) throw new Error("不能给当前会话自身发送消息。");
+    const deps = service();
+    const operation = operationFor([sender, id]);
+    const active = () => {
+      if (!operation.active()) return false;
+      deps.assertAllowed(sender, "send");
+      return true;
+    };
+    try {
+      if (!active()) throw new Error("会话已删除或正在删除。");
+      const [source, destination] = await Promise.all([
+        deps.resolveExistingSession(sender), deps.resolveExistingSession(id),
+      ]);
+      if (!active()) throw new Error("会话已删除或正在删除。");
+      if (!source || !destination) throw new Error("会话不存在。");
+      const destinationCwd = destination.cwd;
+      const destinationId = await pathIdentity(destinationCwd);
+      if (!active()) throw new Error("会话已删除或正在删除。");
+      const live = await deps.getOrCreate(id, destination.projectPath, active);
+      // /cd and worktree removal can race startup. Do not silently send into a
+      // different directory from the one validated above.
+      if (!sameIdentity(live.cwd, await pathIdentity(live.cwd), destinationCwd, destinationId)) throw new Error("目标会话位置发生变化，请重试。");
+      if (!active()) throw new Error("会话已删除或正在删除。");
+      if (!(await sameTarget(destination, await deps.resolveExistingSession(id)))) throw new Error("目标会话位置发生变化，请重试。");
+      if (!active()) throw new Error("会话已删除或正在删除。");
+      const alias = aliasForTarget(id, sender) ?? "";
+      const body = `Message from session ${sender}\nSource alias: ${JSON.stringify(alias)}\n\n${text}`;
+      if (!(await live.sendPeerText(crypto.randomUUID(), body, active))) throw new Error("消息未入队，会话已停止或删除，请重试。");
+      return { sessionId: id, status: "queued" };
+    } finally { operation.release(); }
+  },
+};