@thaut/claude-ide 0.0.0-stage → 1.0.0

package/server/http-channel-routes.ts

@@ -0,0 +1,73 @@
+import type { Hono } from "hono";
+import { getSessionInfo } from "@anthropic-ai/claude-agent-sdk";
+import { db } from "./db.ts";
+import { HttpError, projectPath } from "./sessions.ts";
+import { historyCwd } from "./session-dirs.ts";
+import { createBinding, saveSource, sourceInfo, sourceRow } from "./http-channel-store.ts";
+import { httpChannels } from "./http-channel-manager.ts";
+import type { HttpBindingOverrides, HttpChannelDirection, HttpSourceInput } from "../shared/http-channels.ts";
+
+/** Registered after the shared authentication and same-origin middleware. */
+export function registerHttpChannelRoutes(app: Hono) {
+  app.get("/api/http-channels", (c) => c.json(httpChannels.info(c.req.query("sessionId"))));
+  app.get("/api/http-channels/sources/:id", (c) => {
+    const source = sourceRow(c.req.param("id"));
+    if (!source) throw new HttpError(404, "HTTP 源不存在");
+    const headers = new Headers(JSON.parse(source.headers_json));
+    headers.delete("content-type");
+    c.header("Cache-Control", "no-store");
+    return c.json({ ...sourceInfo(source), hasHeaders: [...headers].length > 0, headers: Object.fromEntries(headers), extraBody: JSON.parse(source.extra_body_json) });
+  });
+
+  app.post("/api/http-channels/sources", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body !== "object") throw new HttpError(400, "请提供源配置");
+    return c.json(sourceInfo(saveSource(body as HttpSourceInput)), 201);
+  });
+  app.put("/api/http-channels/sources/:id", async (c) => {
+    const id = c.req.param("id");
+    if (!sourceRow(id)) throw new HttpError(404, "HTTP 源不存在");
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body !== "object") throw new HttpError(400, "请提供源配置");
+    const source = saveSource(body as HttpSourceInput, id);
+    httpChannels.sourceChanged(id);
+    return c.json(sourceInfo(source));
+  });
+  app.delete("/api/http-channels/sources/:id", (c) => {
+    httpChannels.removeSource(c.req.param("id"));
+    return c.json({ ok: true });
+  });
+
+  app.post("/api/projects/:pid/sessions/:sid/http-bindings", async (c) => {
+    const project = projectPath(c.req.param("pid"));
+    const sessionId = c.req.param("sid");
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body.sourceId !== "string" || !["subscribe", "push"].includes(body.direction)) throw new HttpError(400, "请选择 HTTP 源和方向");
+    // CLI-created sessions also need a durable owner record for background restoration.
+    if (!db.prepare("SELECT 1 FROM session_view WHERE session_id=?").get(sessionId)) {
+      if (!await getSessionInfo(sessionId, { dir: await historyCwd(project, sessionId) }).catch(() => undefined)) throw new HttpError(404, "会话不存在");
+      db.prepare("INSERT OR IGNORE INTO session_view (session_id, project_path) VALUES (?, ?)").run(sessionId, project);
+    }
+    const binding = createBinding(sessionId, body.sourceId, body.direction as HttpChannelDirection, body as HttpBindingOverrides);
+    return c.json({ id: binding.id }, 201);
+  });
+
+  app.patch("/api/http-channels/bindings/:id", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body !== "object" || Array.isArray(body)) throw new HttpError(400, "请提供注册配置");
+    httpChannels.updateBinding(c.req.param("id"), body as HttpBindingOverrides);
+    return c.json({ ok: true });
+  });
+
+  app.post("/api/http-channels/bindings/:id/activation", async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (typeof body?.active !== "boolean") throw new HttpError(400, "请指定激活状态");
+    const id = c.req.param("id");
+    const deactivatedId = body.active ? httpChannels.activate(id) : (httpChannels.deactivate(id), null);
+    return c.json({ ok: true, deactivatedId });
+  });
+  app.delete("/api/http-channels/bindings/:id", (c) => {
+    httpChannels.removeBinding(c.req.param("id"));
+    return c.json({ ok: true });
+  });
+}

package/server/http-channel-store.ts

@@ -0,0 +1,142 @@
+import crypto from "node:crypto";
+import { validateHeaderValue } from "node:http";
+import { db } from "./db.ts";
+import { HttpError } from "./sessions.ts";
+import { encodeProjectId } from "../shared/protocol.ts";
+import type { HttpBindingOverrides, HttpChannelBinding, HttpChannelDirection, HttpSource, HttpSourceInput, HttpSubscribeMethod, HttpSourceKind } from "../shared/http-channels.ts";
+
+export type SourceRow = { id: string; name: string; url: string; headers_json: string; timeout_ms: number; extra_body_json: string; subscribe_method: HttpSubscribeMethod; kind: HttpSourceKind; brain_id: string | null; brain_voice: string | null };
+export type BindingRow = { id: string; session_id: string; source_id: string; direction: HttpChannelDirection; brain_id: string | null; brain_voice: string | null; active: number; activated_at: number | null; inactive_reason: string | null };
+
+export function effectiveBrain(source: SourceRow, binding: BindingRow) {
+  return { brainId: binding.brain_id ?? source.brain_id, brainVoice: binding.brain_voice ?? source.brain_voice };
+}
+
+function validatedBrainId(value: unknown): string | null {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== "string" || value.length > 256) throw new HttpError(400, "brain_id 应为字符串（最多 256 字）");
+  return value.trim() || null;
+}
+
+function validatedBrainVoice(value: unknown): string | null {
+  if (value === undefined || value === null) return null;
+  if (typeof value !== "string" || value.length > 1024) throw new HttpError(400, "x-brain-voice 应为字符串（最多 1024 字）");
+  try {
+    validateHeaderValue("x-brain-voice", value);
+    return new Headers({ "x-brain-voice": value }).get("x-brain-voice")?.trim() ?? "";
+  } catch { throw new HttpError(400, "x-brain-voice 请求头值无效"); }
+}
+
+export function validatedBindingOverrides(source: SourceRow, input: HttpBindingOverrides) {
+  if (source.kind !== "brain-api") {
+    if (input.brainId != null || input.brainVoice != null) throw new HttpError(400, "只有 brain-api 注册支持 brain 配置");
+    return { brainId: null, brainVoice: null };
+  }
+  return { brainId: validatedBrainId(input.brainId), brainVoice: validatedBrainVoice(input.brainVoice) };
+}
+
+export function saveBindingOverrides(id: string, input: HttpBindingOverrides): BindingRow {
+  const row = bindingRow(id);
+  if (!row) throw new HttpError(404, "注册不存在");
+  const source = sourceRow(row.source_id);
+  if (!source) throw new HttpError(404, "HTTP 源不存在");
+  const data = validatedBindingOverrides(source, {
+    brainId: input.brainId === undefined ? row.brain_id : input.brainId,
+    brainVoice: input.brainVoice === undefined ? row.brain_voice : input.brainVoice,
+  });
+  if (row.active && source.kind === "brain-api" && !(data.brainId ?? source.brain_id)) throw new HttpError(400, "激活 brain-api 前，请在源或会话注册中填写 brain_id");
+  db.prepare("UPDATE session_http_bindings SET brain_id=?, brain_voice=? WHERE id=?").run(data.brainId, data.brainVoice, id);
+  return bindingRow(id)!;
+}
+
+export function sourceRow(id: string) {
+  return db.prepare("SELECT * FROM http_sources WHERE id = ?").get(id) as SourceRow | undefined;
+}
+export function bindingRow(id: string) {
+  return db.prepare("SELECT * FROM session_http_bindings WHERE id = ?").get(id) as BindingRow | undefined;
+}
+export function activeRows() {
+  return db.prepare("SELECT * FROM session_http_bindings WHERE active = 1 ORDER BY activated_at DESC, id LIMIT 32").all() as BindingRow[];
+}
+export function sourceInfo(row: SourceRow): HttpSource {
+  return { id: row.id, kind: row.kind, brainId: row.brain_id, brainVoice: row.brain_voice, name: row.name, url: row.url, timeoutMs: row.timeout_ms, subscribeMethod: row.subscribe_method, hasHeaders: row.headers_json !== "{}", hasExtraBody: row.extra_body_json !== "{}" };
+}
+export function listSources() {
+  return (db.prepare("SELECT * FROM http_sources ORDER BY name, id").all() as SourceRow[]).map(sourceInfo);
+}
+export function listBindings(sessionId?: string): HttpChannelBinding[] {
+  const query = `SELECT b.*, v.project_path FROM session_http_bindings b JOIN session_view v ON v.session_id = b.session_id
+    ${sessionId ? "WHERE b.session_id = ?" : ""} ORDER BY b.active DESC, b.created_at DESC`;
+  const statement = db.prepare(query);
+  const rows = (sessionId ? statement.all(sessionId) : statement.all()) as (BindingRow & { project_path: string })[];
+  return rows.map((row) => ({
+    id: row.id, sessionId: row.session_id, sourceId: row.source_id, projectId: encodeProjectId(row.project_path),
+    direction: row.direction, brainId: row.brain_id, brainVoice: row.brain_voice, active: !!row.active, activatedAt: row.activated_at, inactiveReason: row.inactive_reason, stats: null,
+  }));
+}
+
+function validatedSource(input: HttpSourceInput) {
+  const kind = input.kind === undefined ? "http" : input.kind;
+  if (kind !== "http" && kind !== "brain-api") throw new HttpError(400, "源类型无效");
+  let brainId: string | null = null;
+  let brainVoice: string | null = null;
+  if (kind === "brain-api") {
+    brainId = validatedBrainId(input.brainId);
+    brainVoice = validatedBrainVoice(input.brainVoice) || null;
+  }
+  const name = kind === "brain-api" && (input.name === undefined || input.name === "") ? brainId ? `brain-api · ${brainId.slice(0, 80)}` : "brain-api" : input.name;
+  if (typeof name !== "string" || !name.trim() || name.length > 100) throw new HttpError(400, "请填写源名称（最多 100 字）");
+  if (typeof input.url !== "string" || input.url.length > 4096) throw new HttpError(400, "请填写 HTTP 地址");
+  let url: URL;
+  try { url = new URL(input.url); } catch { throw new HttpError(400, "HTTP 地址无效"); }
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash) throw new HttpError(400, "请使用 HTTP/HTTPS 地址；鉴权信息请放在请求头中");
+  const timeout = input.timeoutMs ?? 120_000;
+  if (!Number.isInteger(timeout) || timeout < 1000 || timeout > 600_000) throw new HttpError(400, "请求超时应为 1～600 秒");
+  const subscribeMethod = kind === "brain-api" ? "POST" : input.subscribeMethod === undefined ? "GET" : input.subscribeMethod;
+  if (subscribeMethod !== "GET" && subscribeMethod !== "POST") throw new HttpError(400, "订阅请求方式只能是 GET 或 POST");
+  const headers = input.headers ?? {};
+  if (!headers || typeof headers !== "object" || Array.isArray(headers) || Object.values(headers).some((value) => typeof value !== "string") || JSON.stringify(headers).length > 16_384) throw new HttpError(400, "请求头应为 JSON 字符串键值对象，最大 16KB");
+  let normalized: Headers;
+  try { normalized = new Headers(headers); } catch { throw new HttpError(400, "请求头无效"); }
+  // Content-Type is owned by the JSON protocol, never by source configuration.
+  normalized.delete("content-type");
+  const extraBody = kind === "brain-api" || input.extraBody === undefined ? {} : input.extraBody;
+  if (!extraBody || typeof extraBody !== "object" || Array.isArray(extraBody) || Buffer.byteLength(JSON.stringify(extraBody)) > 16_384) throw new HttpError(400, "Extra body 应为 JSON 对象，最大 16KB");
+  const pending = [{ value: extraBody as unknown, depth: 0 }];
+  while (pending.length) {
+    const { value, depth } = pending.pop()!;
+    if (value && typeof value === "object") {
+      if (depth > 32) throw new HttpError(400, "Extra body 嵌套最多 32 层");
+      for (const child of Object.values(value)) pending.push({ value: child, depth: depth + 1 });
+    }
+  }
+  if (["kind", "id", "text", "sessionId"].some((key) => Object.hasOwn(extraBody, key))) throw new HttpError(400, "Extra body 不能覆盖 kind、id、text、sessionId");
+  return { kind, brainId, brainVoice, name: name.trim(), url: url.href, headers: JSON.stringify(Object.fromEntries(normalized)), extraBody: JSON.stringify(extraBody), timeout, subscribeMethod };
+}
+export function saveSource(input: HttpSourceInput, id: string = crypto.randomUUID()): SourceRow {
+  const previous = sourceRow(id);
+  if (previous && input.kind !== undefined && input.kind !== previous.kind) throw new HttpError(400, "已有源不能更改类型，请新建一个源");
+  const data = validatedSource({ ...input, kind: input.kind === undefined ? previous?.kind : input.kind, brainId: input.brainId === undefined ? previous?.brain_id : input.brainId, brainVoice: input.brainVoice === undefined ? previous?.brain_voice : input.brainVoice, subscribeMethod: input.subscribeMethod === undefined ? previous?.subscribe_method : input.subscribeMethod, headers: input.headers ?? (previous ? JSON.parse(previous.headers_json) : {}), extraBody: input.extraBody === undefined ? (previous ? JSON.parse(previous.extra_body_json) : {}) : input.extraBody });
+  db.prepare(`INSERT INTO http_sources (id, name, url, headers_json, timeout_ms, extra_body_json, subscribe_method, kind, brain_id, brain_voice) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET name=excluded.name, url=excluded.url, headers_json=excluded.headers_json, timeout_ms=excluded.timeout_ms, extra_body_json=excluded.extra_body_json, subscribe_method=excluded.subscribe_method, kind=excluded.kind, brain_id=excluded.brain_id, brain_voice=excluded.brain_voice`)
+    .run(id, data.name, data.url, data.headers, data.timeout, data.extraBody, data.subscribeMethod, data.kind, data.brainId, data.brainVoice);
+  return sourceRow(id)!;
+}
+export function createBinding(sessionId: string, sourceId: string, direction: HttpChannelDirection, overrides: HttpBindingOverrides = {}): BindingRow {
+  const source = sourceRow(sourceId);
+  if (!source) throw new HttpError(404, "HTTP 源不存在");
+  if (!["subscribe", "push"].includes(direction)) throw new HttpError(400, "请选择订阅或推送");
+  if (source.kind === "brain-api" && direction !== "subscribe") throw new HttpError(400, "brain-api 订阅已包含推送，不需要单独注册推送");
+  const data = validatedBindingOverrides(source, overrides);
+  if (db.prepare("SELECT id FROM session_http_bindings WHERE session_id=? AND source_id=? AND direction=?").get(sessionId, sourceId, direction)) throw new HttpError(409, "这个会话已经注册了该源和方向");
+  const id = crypto.randomUUID();
+  db.prepare("INSERT INTO session_http_bindings (id, session_id, source_id, direction, brain_id, brain_voice, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)")
+    .run(id, sessionId, sourceId, direction, data.brainId, data.brainVoice, Date.now());
+  return bindingRow(id)!;
+}
+export function setBindingActive(id: string, active: boolean, reason: string | null = null) {
+  // Monotonic activation time gives FIFO eviction a deterministic order even within one millisecond.
+  const max = (db.prepare("SELECT MAX(activated_at) AS latest FROM session_http_bindings").get() as { latest: number | null }).latest ?? 0;
+  db.prepare("UPDATE session_http_bindings SET active=?, activated_at=CASE WHEN ?=1 THEN ? ELSE activated_at END, inactive_reason=? WHERE id=?")
+    .run(active ? 1 : 0, active ? 1 : 0, Math.max(Date.now(), max + 1), reason, id);
+}

package/server/http-channel-test-fixture.ts

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { Hono } from "hono";
+
+type Message = Record<string, any>;
+class FakeQuery {
+  received: Message[] = [];
+  private messages: Message[] = [];
+  private waiter?: (message: IteratorResult<Message>) => void;
+  private closed = false;
+  constructor(readonly args: { prompt: AsyncIterable<Message>; options: Record<string, any> }) {
+    void (async () => { for await (const message of args.prompt) this.received.push(message); })();
+  }
+  push(message: Message) {
+    if (this.waiter) { const waiter = this.waiter; this.waiter = undefined; waiter({ value: message, done: false }); }
+    else this.messages.push(message);
+  }
+  close() { this.closed = true; this.waiter?.({ value: undefined, done: true }); }
+  async interrupt() {}
+  async applyFlagSettings() {}
+  [Symbol.asyncIterator]() {
+    return { next: (): Promise<IteratorResult<Message>> => {
+      const message = this.messages.shift();
+      if (message) return Promise.resolve({ value: message, done: false });
+      if (this.closed) return Promise.resolve({ value: undefined, done: true });
+      return new Promise((resolve) => { this.waiter = resolve; });
+    } };
+  }
+}
+
+/** Each test file gets a private DB, private CLI directory and no real SDK subprocesses. */
+export async function channelFixture() {
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "cide-http-channels-"));
+  process.env.CLAUDE_IDE_DATA_DIR = path.join(tmp, "data");
+  process.env.CLAUDE_IDE_PASSWORD = "http-channel-tests";
+  process.env.CLAUDE_CONFIG_DIR = path.join(tmp, "claude");
+  const live = await import("./live-session.ts");
+  const queries: FakeQuery[] = [];
+  live.setQueryImplForTests(((args: FakeQuery["args"]) => { const query = new FakeQuery(args); queries.push(query); return query; }) as never);
+  const { sessions, addProject, createDraftSession } = await import("./sessions.ts");
+  const { db } = await import("./db.ts");
+  const store = await import("./http-channel-store.ts");
+  const { httpChannels, HttpChannelManager } = await import("./http-channel-manager.ts");
+  const { registerHttpChannelRoutes } = await import("./http-channel-routes.ts");
+  const project = await addProject(tmp);
+  const app = new Hono();
+  app.onError((error, context) => context.json({ error: error.message }, "status" in error ? error.status as 400 : 500));
+  registerHttpChannelRoutes(app);
+  const newSession = () => createDraftSession(tmp);
+  const queryFor = (id: string) => queries.find((query) => (query.args.options.sessionId ?? query.args.options.resume) === id);
+  const servers: { close: () => Promise<void> }[] = [];
+  const managers = new Set([httpChannels]);
+  return {
+    tmp, project, app, queries, queryFor, newSession, sessions, db, store, httpChannels,
+    fastManager() {
+      const manager = new HttpChannelManager(async () => { await new Promise<void>((resolve) => setImmediate(resolve)); });
+      managers.add(manager);
+      return manager;
+    },
+    async http(handler: (request: IncomingMessage, response: ServerResponse) => void | Promise<void>) {
+      const server = createServer((request, response) => { Promise.resolve(handler(request, response)).catch(() => { response.statusCode = 500; response.end(); }); });
+      await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+      const address = server.address();
+      if (!address || typeof address === "string") throw new Error("missing test server address");
+      const close = async () => {
+        server.closeAllConnections();
+        await new Promise<void>((resolve) => server.close(() => resolve()));
+      };
+      servers.push({ close });
+      return { url: `http://127.0.0.1:${address.port}`, close };
+    },
+    async reset() {
+      for (const manager of managers) manager.stop();
+      sessions.closeAll();
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      db.exec("DELETE FROM session_http_bindings; DELETE FROM http_sources;");
+      queries.length = 0;
+    },
+    async close() {
+      for (const manager of managers) manager.stop();
+      sessions.closeAll();
+      for (const server of servers) await server.close();
+      await new Promise<void>((resolve) => setImmediate(resolve));
+      db.close();
+      fs.rmSync(tmp, { recursive: true, force: true });
+    },
+    text(id: string, text: string, messageId = "same-api-message") {
+      return { type: "assistant", uuid: id, parent_tool_use_id: null, message: { id: messageId, model: "mock", content: [{ type: "text", text }] } };
+    },
+    id: () => crypto.randomUUID(),
+  };
+}
+
+export async function until(condition: () => boolean, timeoutMs = 2500) {
+  const deadline = Date.now() + timeoutMs;
+  while (!condition()) {
+    if (Date.now() >= deadline) throw new Error("Timed out waiting for HTTP channel behavior");
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+}

package/server/ide-messages-mcp.test.ts

@@ -0,0 +1,82 @@
+import { test, after } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const dir = await fs.mkdtemp(path.join(os.tmpdir(), "cide-messages-tools-"));
+process.env.CLAUDE_IDE_DATA_DIR = dir;
+process.env.CLAUDE_IDE_PASSWORD = "synthetic-messages-test";
+const { db } = await import("./db.ts");
+const { ideMessageTools, ideMessagesServer } = await import("./ide-messages-mcp.ts");
+const { configureSessionMessaging } = await import("./session-messaging.ts");
+const { setAlias, aliasTarget } = await import("./session-aliases.ts");
+after(async () => { db.close(); await fs.rm(dir, { recursive: true, force: true }); });
+
+const sender = "11111111-1111-4111-8111-111111111111";
+const target = "22222222-2222-4222-8222-222222222222";
+const other = "33333333-3333-4333-8333-333333333333";
+
+test("actual MCP handlers bind caller identity and cover address book, delivery, errors, and permission changes", async () => {
+  let writable = true;
+  const delivered: { id: string; body: string }[] = [];
+  configureSessionMessaging({
+    resolveExistingSession: async (id) => [sender, target, other].includes(id) ? { sessionId: id, projectPath: `/projects/${id}`, cwd: `/projects/${id}` } : undefined,
+    getOrCreate: async (id) => ({ cwd: `/projects/${id}`, sendPeerText: async (_uuid, body, active) => {
+      if (!active()) return false;
+      delivered.push({ id, body });
+      return true;
+    } }),
+    assertAllowed: () => { if (!writable) throw new Error("source is read-only"); },
+  });
+  const tools = ideMessageTools(sender);
+  assert.deepEqual(tools.map((tool) => tool.name), ["ide_send_message", "ide_set_alias", "ide_list_alias", "ide_remove_alias"]);
+  assert.equal(ideMessagesServer(sender).type, "sdk");
+  async function invoke(name: string, args: Record<string, unknown> = {}) {
+    const tool = tools.find((tool) => tool.name === name)!;
+    // Simulate the SDK's parsed input dispatch, using the real tool handler.
+    const response = await (tool.handler as (args: Record<string, unknown>, extra: unknown) => Promise<{ content: { type: string; text?: string }[]; isError?: boolean }>)(args, {});
+    const text = response.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+    return { ...response, text };
+  }
+  let response = await invoke("ide_list_alias");
+  assert.deepEqual(JSON.parse(response.text), { session_id: sender, aliases: [] });
+  response = await invoke("ide_set_alias", { session_id: target, alias: "reviewer", from: other });
+  assert.equal(response.isError, undefined);
+  assert.equal(aliasTarget(sender, "reviewer"), target);
+  assert.equal(aliasTarget(other, "reviewer"), undefined);
+  setAlias(target, sender, "planner");
+  response = await invoke("ide_send_message", { to: "reviewer", text: "/btw ordinary peer text", from: other });
+  assert.deepEqual(JSON.parse(response.text), { sessionId: target, status: "queued" });
+  assert.equal(delivered.length, 1);
+  assert.equal(delivered[0]!.id, target);
+  assert.ok(delivered[0]!.body.includes(`Message from session ${sender}`));
+  assert.ok(delivered[0]!.body.includes('Source alias: "planner"'));
+  assert.ok(delivered[0]!.body.endsWith("/btw ordinary peer text"));
+  assert.ok(!delivered[0]!.body.includes(other));
+  response = await invoke("ide_set_alias", { session_id: other, alias: "reviewer" });
+  assert.equal(response.isError, true);
+  assert.match(response.text, /already refers/);
+  response = await invoke("ide_send_message", { to: "missing", text: "no delivery" });
+  assert.equal(response.isError, true);
+  assert.equal(delivered.length, 1);
+
+  writable = false;
+  for (const [name, args] of [
+    ["ide_send_message", { to: "reviewer", text: "blocked" }],
+    ["ide_set_alias", { session_id: other, alias: "new" }],
+    ["ide_remove_alias", { alias: "reviewer" }],
+  ] as const) {
+    response = await invoke(name, args);
+    assert.equal(response.isError, true);
+    assert.match(response.text, /read-only/);
+  }
+  assert.equal((await invoke("ide_list_alias")).isError, undefined);
+  assert.equal(aliasTarget(sender, "reviewer"), target);
+  assert.equal(delivered.length, 1);
+  writable = true;
+  response = await invoke("ide_remove_alias", { alias: "reviewer" });
+  assert.deepEqual(JSON.parse(response.text), { removed: true });
+  assert.equal(aliasTarget(sender, "reviewer"), undefined);
+  assert.equal((await invoke("ide_remove_alias", { alias: "reviewer" })).isError, true);
+});

package/server/ide-messages-mcp.ts

@@ -0,0 +1,47 @@
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import { aliasesFor } from "./session-aliases.ts";
+import { sessionMessaging } from "./session-messaging.ts";
+
+function result(value: unknown, isError = false) {
+  return { content: [{ type: "text" as const, text: typeof value === "string" ? value : JSON.stringify(value) }], ...(isError ? { isError: true } : {}) };
+}
+
+/** Identity is closed over by the host, never accepted from tool arguments. */
+export function ideMessageTools(sessionId: string) {
+  const guarded = (action: () => unknown | Promise<unknown>) => async () => {
+    try { return result(await action()); }
+    catch (error) { return result(error instanceof Error ? error.message : String(error), true); }
+  };
+  return [
+    tool("ide_send_message", "Send text to an existing independent claude-ide session, addressed by Session ID or an Alias in your own address book. Success means queued, not read or answered. Do not automatically reply to every received message.", {
+      to: z.string().trim().min(1).max(100).describe("Target Session ID or your Alias for it"),
+      text: z.string().min(1).max(100_000).describe("Message text; treated as text, not slash commands"),
+    }, async ({ to, text }) => guarded(() => sessionMessaging.send(sessionId, to, text))()),
+    tool("ide_set_alias", "Set or rename your private nickname for an existing session. Each contact has one nickname. A nickname already assigned to another contact is rejected. Other sessions' address books are unaffected.", {
+      session_id: z.string().uuid().describe("Existing target Session ID"),
+      alias: z.string().min(1).max(100).describe("Your nickname for this session; cannot look like a Session ID"),
+    }, async ({ session_id, alias }) => guarded(async () => {
+      await sessionMessaging.setAlias(sessionId, session_id, alias);
+      return { session_id, alias: alias.trim() };
+    })()),
+    tool("ide_list_alias", "List your private address book, along with your own Session ID. These names are local to your session, not globally registered identities.", {},
+      guarded(() => ({ session_id: sessionId, aliases: aliasesFor(sessionId).map(({ alias, sessionId: target }) => ({ alias, session_id: target })) }))),
+    tool("ide_remove_alias", "Remove a nickname from your own address book. Does not stop or delete the target session.", {
+      alias: z.string().min(1).max(100).describe("Your nickname to remove"),
+    }, async ({ alias }) => guarded(async () => {
+      if (!await sessionMessaging.removeAlias(sessionId, alias)) throw new Error("Alias not found in this session's address book");
+      return { removed: true };
+    })()),
+  ];
+}
+
+export function ideMessagesServer(sessionId: string) {
+  return createSdkMcpServer({
+    name: "IDEMessages",
+    version: "1.0.0",
+    alwaysLoad: true,
+    instructions: "IDEMessages sends server-mediated messages to independent claude-ide sessions. Aliases are your private address book. Received source_alias is YOUR nickname for the sender, and is empty when you have not named that sender. Source Session IDs are server supplied. Sending only queues a message; it never waits for a reply. Use this tool for independent sessions, not the native subagent SendMessage tool. Avoid automatic reply loops.",
+    tools: ideMessageTools(sessionId),
+  });
+}

package/server/idecron-mcp.ts

@@ -0,0 +1,65 @@
+import { createSdkMcpServer, tool } from "@anthropic-ai/claude-agent-sdk";
+import { z } from "zod";
+import { idecron } from "./idecron.ts";
+
+const mode = z.enum(["steer", "next_turn", "interrupt"]);
+
+function text(value: string, isError = false) {
+  return { content: [{ type: "text" as const, text: value }], ...(isError ? { isError: true } : {}) };
+}
+
+/** In-process MCP server injected into one claude-ide session. */
+export function ideCronServer(sessionId: string, projectPath: string | (() => string)) {
+  const project = () => typeof projectPath === "function" ? projectPath() : projectPath;
+  return createSdkMcpServer({
+    name: "IDECron",
+    version: "1.0.0",
+    alwaysLoad: true,
+    instructions: "IDECron owns server-side schedules for this claude-ide session. It fires even when the CLI scheduler is busy: use mode steer to queue into the current turn, or next_turn to wait for an idle session.",
+    tools: [
+      tool(
+        "schedule_create",
+        "Create a server-side IDECron schedule for this session. `when` accepts a 5-field cron, an ISO timestamp, or an interval such as 10m/2h/1d. Use mode=steer to deliver at the next safe point of the current turn, next_turn to wait until the session is idle, or interrupt to stop the current turn first.",
+        {
+          when: z.string().min(1).describe("Cron expression, ISO timestamp, or interval such as 10m/2h/1d"),
+          prompt: z.string().min(1).describe("Prompt to send when the schedule fires"),
+          recurring: z.boolean().optional().describe("Whether the schedule repeats; defaults to true for cron/interval and false for ISO timestamps"),
+          mode: mode.optional().describe("Delivery while the session is busy; defaults to steer"),
+        },
+        async ({ when, prompt, recurring, mode: delivery }) => {
+          try {
+            const task = idecron.create({ sessionId, projectPath: project(), when, prompt, recurring, mode: delivery });
+            return text(`Created IDECron task ${task.id}. Next run: ${new Date(task.nextRunAt).toISOString()}${task.recurring ? " (recurring)" : " (one-shot)"}.`);
+          } catch (err) {
+            return text(`Could not create IDECron task: ${err instanceof Error ? err.message : String(err)}`, true);
+          }
+        },
+      ),
+      tool(
+        "schedule_list",
+        "List this session's server-side IDECron schedules.",
+        {},
+        async () => {
+          const tasks = idecron.list(sessionId);
+          if (!tasks.length) return text("No IDECron schedules.");
+          return text(tasks.map((t) => JSON.stringify({
+            id: t.id,
+            schedule: t.schedule,
+            recurring: t.recurring,
+            mode: t.mode,
+            nextRun: new Date(t.nextRunAt).toISOString(),
+            prompt: t.prompt,
+          })).join("\n"));
+        },
+      ),
+      tool(
+        "schedule_cancel",
+        "Cancel one of this session's server-side IDECron schedules by id.",
+        { id: z.string().min(1).describe("IDECron task id") },
+        async ({ id }) => idecron.cancel(id, sessionId)
+          ? text(`Cancelled IDECron task ${id}.`)
+          : text(`No IDECron task ${id} owned by this session.`, true),
+      ),
+    ],
+  });
+}

package/server/idecron.test.ts

@@ -0,0 +1,79 @@
+import { test, before } from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import crypto from "node:crypto";
+
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "cide-idecron-"));
+process.env.CLAUDE_IDE_DATA_DIR = path.join(tmp, "data");
+process.env.CLAUDE_IDE_PASSWORD = "unit";
+
+let idecron: typeof import("./idecron.ts").idecron;
+let db: typeof import("./db.ts").db;
+
+before(async () => {
+  ({ idecron } = await import("./idecron.ts"));
+  ({ db } = await import("./db.ts"));
+});
+
+const session = () => crypto.randomUUID();
+
+test("IDECron creates, lists, and cancels a session-owned task", () => {
+  const sid = session();
+  const task = idecron.create({ sessionId: sid, projectPath: "/tmp", when: "10m", prompt: "ping" });
+  assert.equal(task.recurring, true);
+  assert.equal(task.mode, "steer");
+  assert.ok(task.nextRunAt > Date.now());
+  assert.deepEqual(idecron.list(sid).map((t) => t.id), [task.id]);
+  const cron = idecron.cronsFor(sid)[0]!;
+  assert.equal(cron.server, true);
+  assert.equal(cron.schedule, "10m");
+  assert.equal(cron.recurring, true);
+  assert.equal(idecron.cancel(task.id, session()), false, "another session cannot cancel it");
+  assert.equal(idecron.cancel(task.id, sid), true);
+  assert.deepEqual(idecron.list(sid), []);
+});
+
+test("IDECron delivery is coalesced and reschedules recurring tasks", async () => {
+  const sid = session();
+  const delivered: string[] = [];
+  idecron.setDelivery({ canDeliver: () => true, deliver: (t) => { delivered.push(t.id); return true; } });
+  const recurring = idecron.create({ sessionId: sid, projectPath: "/tmp", when: "1m", prompt: "tick" });
+  db.prepare("UPDATE idecron_schedules SET next_run_at = ? WHERE id = ?").run(Date.now() - 1_000, recurring.id);
+  await idecron.tick();
+  assert.deepEqual(delivered, [recurring.id]);
+  const after = idecron.list(sid)[0]!;
+  assert.equal(after.id, recurring.id);
+  assert.ok(after.nextRunAt > Date.now());
+
+  const once = idecron.create({ sessionId: sid, projectPath: "/tmp", when: new Date(Date.now() + 60_000).toISOString(), prompt: "once" });
+  db.prepare("UPDATE idecron_schedules SET next_run_at = ? WHERE id = ?").run(Date.now() - 1_000, once.id);
+  await idecron.tick();
+  assert.deepEqual(delivered, [recurring.id, once.id]);
+  assert.deepEqual(idecron.list(sid).map((t) => t.id), [recurring.id]);
+  idecron.cancelSession(sid);
+});
+
+test("next_turn waits until the session is deliverable", async () => {
+  const sid = session();
+  let allowed = false;
+  const delivered: string[] = [];
+  idecron.setDelivery({ canDeliver: () => allowed, deliver: (t) => { delivered.push(t.id); return true; } });
+  const task = idecron.create({ sessionId: sid, projectPath: "/tmp", when: new Date(Date.now() + 60_000).toISOString(), prompt: "later", mode: "next_turn" });
+  db.prepare("UPDATE idecron_schedules SET next_run_at = ? WHERE id = ?").run(Date.now() - 1_000, task.id);
+  await idecron.tick();
+  assert.deepEqual(delivered, []);
+  assert.equal(idecron.list(sid).length, 1);
+  allowed = true;
+  await idecron.tick();
+  assert.deepEqual(delivered, [task.id]);
+  assert.deepEqual(idecron.list(sid), []);
+});
+
+test("IDECron rejects invalid schedules", () => {
+  const sid = session();
+  assert.throws(() => idecron.create({ sessionId: sid, projectPath: "/tmp", when: "not a schedule", prompt: "x" }), /无法解析/);
+  assert.throws(() => idecron.create({ sessionId: sid, projectPath: "/tmp", when: "1s", prompt: "x" }), /至少 1 分钟/);
+  assert.throws(() => idecron.create({ sessionId: sid, projectPath: "/tmp", when: new Date(Date.now() + 60_000).toISOString(), prompt: "x", recurring: true }), /一次性/);
+});