khala-cli 0.3.0

package/dist/chunk-HWKLLI7F.mjs

@@ -0,0 +1,1652 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  LOCAL_AGENT_DEVICE_PREFIX,
+  LOCAL_IDLE_EXIT_MS,
+  LOCAL_LINK_TTL_MS,
+  LOCAL_LONG_POLL_MAX_S,
+  LOCAL_OWNER_DEVICE_ID,
+  LOCAL_OWNER_ID,
+  LOCAL_OWNER_USER_ID,
+  LOCAL_TOKEN_BYTES,
+  base64url,
+  decodeChannelSecrets,
+  decodeLocalEvent,
+  decodeOwnerProfile,
+  ensureHelper,
+  helperPaths,
+  isLocalRoomId,
+  localRoomKey,
+  newLocalAgentUserId,
+  newLocalEventId,
+  newLocalRoomId,
+  readHelperFile
+} from "./chunk-ZRUF3P53.mjs";
+import {
+  parseChannelLink,
+  resolveLocalOwnerName
+} from "./chunk-UYTGV6TW.mjs";
+import {
+  KHALA_AGENT_VERSION
+} from "./chunk-Y3TDVOGT.mjs";
+import {
+  checkName,
+  defaultAgentName,
+  defaultHumanColor,
+  isDefaultAgentName,
+  isHumanColorId,
+  normalizeInitials
+} from "./chunk-6GOETMWV.mjs";
+import {
+  StateError,
+  ensureStateDir,
+  readJson,
+  writeJsonAtomic
+} from "./chunk-S6XASSNU.mjs";
+import {
+  CHANNEL_EVENT_TYPE,
+  DEFAULT_LISTENING_MODE,
+  LISTENING_MODE_COMMAND_TYPE,
+  LISTENING_MODE_MEMBER_KEY,
+  agentConfirmPagePath,
+  decodeChannelEvent,
+  decodeListeningMode,
+  decodeListeningModeCommand,
+  decodeWith,
+  encodeChannelEvent,
+  memberListeningMode,
+  object,
+  utf8Length
+} from "./chunk-GO5DD2TR.mjs";
+import {
+  bundle
+} from "./chunk-HMGN52QY.mjs";
+import "./chunk-6FNXMYOM.mjs";
+
+// src/local/cli.ts
+import { setTimeout as sleepDefault } from "node:timers/promises";
+
+// src/local/serve.ts
+import { createHash as createHash3, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
+import { unlink } from "node:fs/promises";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/local/store.ts
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+var LocalStoreError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.name = "LocalStoreError";
+    this.code = code;
+  }
+};
+var sha256 = (token) => createHash("sha256").update(token).digest("hex");
+var emptySecrets = () => ({ v: 1, links: {}, members: {} });
+var lastSeq = (channel) => channel.events.at(-1)?.seq ?? 0;
+var fire = (waiters) => {
+  for (const done of [...waiters]) done();
+};
+async function openLocalStore(input) {
+  const { root, now = Date.now, random = randomBytes } = input;
+  const channelsDir = path.join(root, "channels");
+  const channels = /* @__PURE__ */ new Map();
+  const operations = /* @__PURE__ */ new Map();
+  const agentChannel = /* @__PURE__ */ new Map();
+  const deletedAgentTokens = /* @__PURE__ */ new Map();
+  const revisionWaiters = /* @__PURE__ */ new Set();
+  let revision = 0;
+  let queue = Promise.resolve();
+  let closed = false;
+  let closing;
+  let owner2;
+  function makeChannel(roomId) {
+    return {
+      roomId,
+      dir: path.join(channelsDir, localRoomKey(roomId)),
+      name: "",
+      events: [],
+      byEventId: /* @__PURE__ */ new Map(),
+      byTxn: /* @__PURE__ */ new Map(),
+      lastMember: /* @__PURE__ */ new Map(),
+      secrets: emptySecrets(),
+      waiters: /* @__PURE__ */ new Set()
+    };
+  }
+  function indexEvent(channel, event) {
+    channel.events.push(event);
+    channel.byEventId.set(event.eventId, event);
+    if (event.txnId !== void 0) channel.byTxn.set(`${event.sender}\0${event.txnId}`, event);
+    if (event.type === "m.room.create") {
+      channel.name = event.content.name;
+      if (typeof event.content.operationId === "string") channel.operationId = event.content.operationId;
+    } else if (event.type === "m.room.name") channel.name = event.content.name;
+    else if (event.type === "m.room.member") {
+      const user = event.content.user;
+      const firstSeq = channel.lastMember.get(user)?.firstSeq ?? event.seq;
+      channel.lastMember.set(user, { event, firstSeq });
+    }
+  }
+  function register(channel) {
+    channels.set(channel.roomId, channel);
+    if (channel.operationId !== void 0) operations.set(channel.operationId, channel.roomId);
+    for (const user of channel.lastMember.keys()) {
+      if (user !== LOCAL_OWNER_USER_ID) agentChannel.set(user, channel.roomId);
+    }
+  }
+  try {
+    await ensureStateDir(channelsDir);
+    const decodedOwner = decodeOwnerProfile(await readJson(path.join(root, "owner.json")));
+    owner2 = structuredClone(decodedOwner.ok ? decodedOwner.value : input.ownerDefault);
+    for (const entry of await fs.readdir(channelsDir, { withFileTypes: true })) {
+      const roomId = `!${entry.name}:local`;
+      if (!isLocalRoomId(roomId) || !entry.isDirectory() && !entry.isSymbolicLink()) continue;
+      const channel = makeChannel(roomId);
+      await ensureStateDir(channel.dir);
+      let buffer;
+      try {
+        buffer = await fs.readFile(path.join(channel.dir, "log.jsonl"));
+      } catch (error2) {
+        if (error2.code === "ENOENT") continue;
+        throw error2;
+      }
+      const completeBytes = buffer.lastIndexOf(10) + 1;
+      if (completeBytes < buffer.length) channel.validBytes = completeBytes;
+      for (const line of buffer.subarray(0, completeBytes).toString("utf8").split("\n")) {
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        const decoded = decodeLocalEvent(parsed);
+        if (decoded.ok && decoded.value.roomId === roomId && decoded.value.seq > lastSeq(channel)) indexEvent(channel, decoded.value);
+      }
+      if (channel.events[0]?.type !== "m.room.create") continue;
+      const secrets = decodeChannelSecrets(await readJson(path.join(channel.dir, "secrets.json")));
+      channel.secrets = secrets.ok ? secrets.value : emptySecrets();
+      register(channel);
+    }
+  } catch (error2) {
+    if (error2 instanceof StateError && error2.code === "unsafe_state_dir") throw error2;
+    throw new LocalStoreError("storage_failed");
+  }
+  function enqueue(task) {
+    if (closed) return Promise.reject(new LocalStoreError("storage_failed"));
+    const run = queue.then(task).catch((error2) => {
+      if (error2 instanceof LocalStoreError) throw error2;
+      throw new LocalStoreError("storage_failed");
+    });
+    queue = run.catch(() => void 0);
+    return run;
+  }
+  function requireChannel(roomId) {
+    const channel = channels.get(roomId);
+    if (!channel) throw new LocalStoreError("not_found");
+    return channel;
+  }
+  function bump() {
+    revision++;
+    fire(revisionWaiters);
+  }
+  async function writeEvent(channel, eventInput) {
+    const event = {
+      seq: lastSeq(channel) + 1,
+      eventId: newLocalEventId(random(16)),
+      roomId: channel.roomId,
+      type: eventInput.type,
+      sender: eventInput.sender,
+      ts: now(),
+      ...eventInput.txnId !== void 0 ? { txnId: eventInput.txnId } : {},
+      content: eventInput.content
+    };
+    const stored = structuredClone(event);
+    const logPath = path.join(channel.dir, "log.jsonl");
+    if (channel.validBytes !== void 0) {
+      await fs.truncate(logPath, channel.validBytes);
+      delete channel.validBytes;
+    }
+    channel.handle ??= await fs.open(logPath, "a", 384);
+    const start = (await channel.handle.stat()).size;
+    try {
+      await channel.handle.writeFile(JSON.stringify(stored) + "\n", "utf8");
+    } catch (error2) {
+      channel.validBytes = start;
+      throw error2;
+    }
+    indexEvent(channel, stored);
+    return stored;
+  }
+  function waitUntil(ready, waiters, timeoutMs, signal) {
+    if (ready() || signal.aborted || closed) return Promise.resolve();
+    return new Promise((resolve2) => {
+      const done = () => {
+        clearTimeout(timer);
+        signal.removeEventListener("abort", done);
+        waiters.delete(wake);
+        resolve2();
+      };
+      const wake = () => {
+        if (ready() || closed) done();
+      };
+      const timer = setTimeout(done, Math.max(0, timeoutMs));
+      signal.addEventListener("abort", done, { once: true });
+      waiters.add(wake);
+    });
+  }
+  function member(channel, userId) {
+    const event = channel.lastMember.get(userId)?.event;
+    if (!event) return void 0;
+    const content = event.content;
+    const human = userId === LOCAL_OWNER_USER_ID;
+    return {
+      userId,
+      participantId: userId,
+      ownerId: LOCAL_OWNER_ID,
+      deviceId: human ? LOCAL_OWNER_DEVICE_ID : LOCAL_AGENT_DEVICE_PREFIX + userId.slice(7, 15),
+      displayName: human ? owner2.username : content.displayname,
+      kind: content.kind,
+      membership: content.membership,
+      ...!human ? {
+        ownerLabel: owner2.username,
+        listeningMode: memberListeningMode(content),
+        ...content.harness !== void 0 ? { harness: content.harness } : {}
+      } : {}
+    };
+  }
+  function members(channel) {
+    const result = [];
+    const ordered = [...channel.lastMember.entries()].sort(([a, av], [b, bv]) => a === LOCAL_OWNER_USER_ID ? -1 : b === LOCAL_OWNER_USER_ID ? 1 : av.firstSeq - bv.firstSeq);
+    for (const [userId] of ordered) {
+      const value = member(channel, userId);
+      if (value && (value.membership === "invite" || value.membership === "join")) result.push({ ...value, membership: value.membership });
+    }
+    return result;
+  }
+  function summary(channel) {
+    let message;
+    for (let i = channel.events.length - 1; i >= 0; i--) {
+      const event = channel.events[i];
+      if (event.type === "m.room.message" && event.content.msgtype === "m.text" && typeof event.content.body === "string") {
+        message = event;
+        break;
+      }
+    }
+    return {
+      roomId: channel.roomId,
+      name: channel.name,
+      createdAt: new Date(channel.events[0].ts).toISOString(),
+      lastSeq: lastSeq(channel),
+      lastTs: channel.events.at(-1).ts,
+      preview: message ? message.content.body : null,
+      ...message ? { lastSender: { userId: message.sender, displayName: member(channel, message.sender)?.displayName ?? message.sender } } : {},
+      members: members(channel).map((m) => ({
+        userId: m.userId,
+        displayName: m.displayName,
+        kind: m.kind,
+        ...m.harness !== void 0 ? { harness: m.harness } : {}
+      }))
+    };
+  }
+  async function saveSecrets(channel, secrets) {
+    await writeJsonAtomic(path.join(channel.dir, "secrets.json"), secrets);
+    channel.secrets = secrets;
+  }
+  return {
+    listChannels: () => [...channels.values()].map(summary).sort((a, b) => b.lastTs - a.lastTs || b.lastSeq - a.lastSeq || (a.roomId < b.roomId ? -1 : a.roomId > b.roomId ? 1 : 0)),
+    channelSummary: (roomId) => {
+      const c = channels.get(roomId);
+      return c ? summary(c) : void 0;
+    },
+    createChannel: (name, operationId) => enqueue(async () => {
+      const existing = operationId !== void 0 ? operations.get(operationId) : void 0;
+      if (existing) return { roomId: existing, created: false };
+      let channel;
+      while (true) {
+        channel = makeChannel(newLocalRoomId(random(16)));
+        if (channels.has(channel.roomId)) continue;
+        try {
+          await fs.lstat(channel.dir);
+        } catch (error2) {
+          if (error2.code === "ENOENT") break;
+          throw error2;
+        }
+      }
+      await ensureStateDir(channel.dir);
+      try {
+        await writeEvent(channel, {
+          type: "m.room.create",
+          sender: LOCAL_OWNER_USER_ID,
+          content: { name, createdBy: LOCAL_OWNER_USER_ID, ...operationId !== void 0 ? { operationId } : {} }
+        });
+        await writeEvent(channel, {
+          type: "m.room.member",
+          sender: LOCAL_OWNER_USER_ID,
+          content: { user: LOCAL_OWNER_USER_ID, membership: "join", displayname: owner2.username, kind: "human" }
+        });
+        await saveSecrets(channel, emptySecrets());
+      } catch (error2) {
+        await channel.handle?.close();
+        await fs.rm(channel.dir, { recursive: true, force: true });
+        throw error2;
+      }
+      register(channel);
+      bump();
+      bump();
+      return { roomId: channel.roomId, created: true };
+    }),
+    findByOperation: (operationId) => operations.get(operationId),
+    deleteChannel: (roomId) => enqueue(async () => {
+      const channel = channels.get(roomId);
+      if (!channel) return;
+      await channel.handle?.close();
+      delete channel.handle;
+      await fs.rm(channel.dir, { recursive: true, force: true });
+      for (const [userId, secret] of Object.entries(channel.secrets.members)) {
+        if (userId !== LOCAL_OWNER_USER_ID) deletedAgentTokens.set(secret.tokenSha256, { roomId, userId });
+      }
+      channels.delete(roomId);
+      if (channel.operationId !== void 0) operations.delete(channel.operationId);
+      for (const [user, room] of agentChannel) if (room === roomId) agentChannel.delete(user);
+      bump();
+      fire(channel.waiters);
+    }),
+    hasChannel: (roomId) => channels.has(roomId),
+    channelOfMember: (userId) => agentChannel.get(userId),
+    revision: () => revision,
+    waitForRevision: (since, timeoutMs, signal) => waitUntil(() => revision !== since, revisionWaiters, timeoutMs, signal),
+    append: (roomId, eventInput) => {
+      const ownedInput = structuredClone(eventInput);
+      return enqueue(async () => {
+        const channel = requireChannel(roomId);
+        const existing = ownedInput.txnId !== void 0 ? channel.byTxn.get(`${ownedInput.sender}\0${ownedInput.txnId}`) : void 0;
+        if (existing) return structuredClone(existing);
+        const event = await writeEvent(channel, ownedInput);
+        if (event.type === "m.room.member" && event.content.user !== LOCAL_OWNER_USER_ID) agentChannel.set(event.content.user, roomId);
+        bump();
+        fire(channel.waiters);
+        return structuredClone(event);
+      });
+    },
+    eventsAfter: (roomId, after, limit) => {
+      const events = channels.get(roomId)?.events ?? [];
+      let lo = 0;
+      let hi = events.length;
+      while (lo < hi) {
+        const mid = Math.floor((lo + hi) / 2);
+        if (events[mid].seq <= after) lo = mid + 1;
+        else hi = mid;
+      }
+      return structuredClone(events.slice(lo, lo + Math.max(0, limit)));
+    },
+    waitForEvent: (roomId, after, timeoutMs, signal) => {
+      const channel = channels.get(roomId);
+      return channel ? waitUntil(() => !channels.has(roomId) || lastSeq(channel) > after, channel.waiters, timeoutMs, signal) : Promise.resolve();
+    },
+    history: (roomId, before, limit) => {
+      const channel = channels.get(roomId);
+      const cutoff = before !== void 0 ? channel?.byEventId.get(before)?.seq : Infinity;
+      if (!channel || cutoff === void 0 || limit <= 0) return { events: [] };
+      const candidates = channel.events.filter((e) => e.seq < cutoff && (e.type === "m.room.message" || e.type === "com.khala.event.v1"));
+      const events = candidates.slice(-limit);
+      return { events: structuredClone(events), ...candidates.length > events.length ? { nextBefore: events[0].eventId } : {} };
+    },
+    members: (roomId) => {
+      const c = channels.get(roomId);
+      return c ? members(c) : [];
+    },
+    member: (roomId, userId) => {
+      const c = channels.get(roomId);
+      return c ? member(c, userId) : void 0;
+    },
+    channelName: (roomId) => channels.get(roomId)?.name ?? "",
+    mintLink: (roomId, kind) => enqueue(async () => {
+      const channel = requireChannel(roomId);
+      const token = base64url(random(LOCAL_TOKEN_BYTES));
+      const expiresAt = new Date(now() + LOCAL_LINK_TTL_MS).toISOString();
+      await saveSecrets(channel, { ...channel.secrets, links: { ...channel.secrets.links, [sha256(token)]: { expiresAt, kind } } });
+      return { token, expiresAt };
+    }),
+    consumeLink: (token) => enqueue(async () => {
+      if (!/^[A-Za-z0-9_-]{43}$/u.test(token)) return null;
+      const hash2 = sha256(token);
+      for (const channel of channels.values()) {
+        const link = channel.secrets.links[hash2];
+        if (!link || link.consumedAt !== void 0 || Date.parse(link.expiresAt) <= now()) continue;
+        const consumedAt = new Date(now()).toISOString();
+        await saveSecrets(channel, { ...channel.secrets, links: { ...channel.secrets.links, [hash2]: { ...link, consumedAt } } });
+        return { roomId: channel.roomId };
+      }
+      return null;
+    }),
+    setMemberToken: (roomId, userId, tokenSha256) => enqueue(async () => {
+      const channel = requireChannel(roomId);
+      const next = { ...channel.secrets.members };
+      if (tokenSha256 === null) delete next[userId];
+      else if (userId !== LOCAL_OWNER_USER_ID) next[userId] = { tokenSha256 };
+      await saveSecrets(channel, { ...channel.secrets, members: next });
+    }),
+    agentForToken: (token) => {
+      const hash2 = Buffer.from(sha256(token), "hex");
+      let result = null;
+      for (const [tokenSha256, agent] of deletedAgentTokens) {
+        const candidate = Buffer.from(tokenSha256, "hex");
+        if (candidate.length === hash2.length && timingSafeEqual(hash2, candidate)) result = { ...agent };
+      }
+      for (const channel of channels.values()) for (const [userId, secret] of Object.entries(channel.secrets.members)) {
+        const candidate = Buffer.from(secret.tokenSha256, "hex");
+        if (candidate.length === hash2.length && timingSafeEqual(hash2, candidate) && userId !== LOCAL_OWNER_USER_ID) result = { roomId: channel.roomId, userId };
+      }
+      return result;
+    },
+    owner: () => structuredClone(owner2),
+    setOwner: (next) => {
+      const owned = structuredClone(next);
+      return enqueue(async () => {
+        await writeJsonAtomic(path.join(root, "owner.json"), owned);
+        owner2 = owned;
+        bump();
+      });
+    },
+    close: () => {
+      if (!closing) {
+        closed = true;
+        closing = (async () => {
+          await queue;
+          try {
+            await Promise.all([...channels.values()].map((c) => c.handle?.close()));
+          } finally {
+            fire(revisionWaiters);
+            for (const channel of channels.values()) fire(channel.waiters);
+          }
+        })();
+      }
+      return closing;
+    }
+  };
+}
+
+// src/local/http.ts
+import { createServer } from "node:http";
+import * as fs2 from "node:fs/promises";
+import path2 from "node:path";
+var LOCAL_OWNER_COOKIE = "khala_local_owner";
+var LOCAL_BODY_LIMIT_BYTES = 65536;
+var LOCAL_CSP = "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; font-src 'self'; img-src 'self' data:; connect-src 'self'; frame-ancestors 'none'; base-uri 'none'; object-src 'none'";
+var mime = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon",
+  ".woff2": "font/woff2",
+  ".txt": "text/plain; charset=utf-8"
+};
+function respond(res, result) {
+  if (res.destroyed || res.writableEnded) return;
+  for (const [key, value] of Object.entries(result.headers ?? {})) {
+    if (!key.toLowerCase().startsWith("access-control-")) res.setHeader(key, value);
+  }
+  res.setHeader("cache-control", "no-store");
+  res.setHeader("x-content-type-options", "nosniff");
+  if ("location" in result) {
+    res.statusCode = 302;
+    res.setHeader("location", result.location);
+    res.end();
+  } else {
+    const body = result.json === void 0 ? void 0 : JSON.stringify(result.json);
+    res.statusCode = result.status;
+    if (body !== void 0) res.setHeader("content-type", "application/json; charset=utf-8");
+    res.end(body);
+  }
+}
+function error(res, status, code) {
+  respond(res, { status, json: { error: code } });
+}
+function readBody(req, signal) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    let size = 0;
+    const cleanup = () => {
+      req.off("data", data);
+      req.off("end", end);
+      req.off("error", fail5);
+      signal.removeEventListener("abort", abort);
+    };
+    const fail5 = (err) => {
+      cleanup();
+      reject(err);
+    };
+    const abort = () => fail5(new Error("client_disconnected"));
+    const data = (chunk) => {
+      size += chunk.length;
+      if (size > LOCAL_BODY_LIMIT_BYTES) {
+        cleanup();
+        chunks.length = 0;
+        req.resume();
+        reject(new Error("payload_too_large"));
+      } else chunks.push(chunk);
+    };
+    const end = () => {
+      cleanup();
+      try {
+        resolve2(size === 0 ? void 0 : JSON.parse(Buffer.concat(chunks).toString("utf8")));
+      } catch {
+        reject(new Error("invalid_request"));
+      }
+    };
+    req.on("data", data);
+    req.on("end", end);
+    req.on("error", fail5);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+  });
+}
+var inside = (root, file) => file === root || file.startsWith(root + path2.sep);
+function createHelperServer(options) {
+  let port = 0;
+  let origin = "";
+  let ctx;
+  let inFlight = 0;
+  let timer;
+  let closing = false;
+  let closePromise;
+  let listenPromise;
+  let cancelListen;
+  const controllers = /* @__PURE__ */ new Set();
+  const webDir = path2.resolve(options.webDir);
+  const log = options.log ?? ((line) => {
+    process.stderr.write(line + "\n");
+  });
+  const armIdle = () => {
+    clearTimeout(timer);
+    if (!closing) timer = setTimeout(() => {
+      if (inFlight === 0 && !closing) options.onIdle();
+    }, options.idleMs);
+  };
+  const server = createServer((req, res) => {
+    inFlight++;
+    clearTimeout(timer);
+    const controller = new AbortController();
+    controllers.add(controller);
+    res.once("close", () => {
+      if (!res.writableEnded) controller.abort();
+      controllers.delete(controller);
+      inFlight--;
+      if (inFlight === 0) armIdle();
+    });
+    void handle(req, res, controller.signal);
+  });
+  async function serveStatic(encoded, res) {
+    const index = path2.join(webDir, "index.html");
+    try {
+      if (!(await fs2.stat(index)).isFile()) return error(res, 503, "web_not_built");
+    } catch {
+      return error(res, 503, "web_not_built");
+    }
+    let decoded;
+    try {
+      decoded = decodeURIComponent(encoded);
+    } catch {
+      return error(res, 400, "invalid_request");
+    }
+    let file = path2.join(webDir, decoded);
+    if (decoded.includes("\0") || !inside(webDir, file)) return error(res, 404, "not_found");
+    const root = await fs2.realpath(webDir);
+    let regular = false;
+    try {
+      if ((await fs2.stat(file)).isFile()) {
+        file = await fs2.realpath(file);
+        if (!inside(root, file)) return error(res, 404, "not_found");
+        regular = true;
+      }
+    } catch {
+    }
+    if (!regular) {
+      if (decoded.startsWith("/assets/")) return error(res, 404, "not_found");
+      file = await fs2.realpath(index);
+      if (!inside(root, file)) return error(res, 404, "not_found");
+    }
+    const bytes = await fs2.readFile(file);
+    if (res.destroyed) return;
+    const extension = path2.extname(file).toLowerCase();
+    res.statusCode = 200;
+    res.setHeader("content-type", mime[extension] ?? "application/octet-stream");
+    res.setHeader("cache-control", "no-cache");
+    res.setHeader("x-content-type-options", "nosniff");
+    if (extension === ".html") {
+      res.setHeader("content-security-policy", LOCAL_CSP);
+      res.setHeader("referrer-policy", "no-referrer");
+    }
+    res.end(bytes);
+  }
+  async function handle(req, res, signal) {
+    let routeIndex = -1;
+    try {
+      const host = req.headers.host?.toLowerCase();
+      if (host !== `127.0.0.1:${port}` && host !== `localhost:${port}`) return error(res, 421, "misdirected");
+      const method = req.method;
+      if (method !== "GET" && method !== "POST" && method !== "PUT" && method !== "DELETE") return error(res, 405, "method_not_allowed");
+      let url;
+      try {
+        url = new URL(req.url, origin);
+      } catch {
+        return error(res, 400, "invalid_request");
+      }
+      const pathname = url.pathname;
+      if (pathname === "/healthz") return method === "GET" ? respond(res, { status: 200, json: { ok: true, version: ctx.version, pid: process.pid } }) : error(res, 405, "method_not_allowed");
+      let auth = { kind: "none" };
+      const authorization = req.headers.authorization;
+      if (authorization !== void 0) {
+        const bearer = /^Bearer ([A-Za-z0-9_-]{16,256})$/.exec(authorization);
+        if (bearer) auth = options.authenticateBearer(bearer[1]);
+      } else {
+        const value = req.headers.cookie?.split(";").map((piece) => piece.trim()).find((piece) => piece.startsWith(LOCAL_OWNER_COOKIE + "="))?.slice(LOCAL_OWNER_COOKIE.length + 1);
+        if (value && /^[A-Za-z0-9_-]{43}$/.test(value) && options.authenticateCookie(value)) auth = { kind: "owner", via: "cookie" };
+      }
+      if (authorization === void 0 && method !== "GET" && auth.kind === "owner" && auth.via === "cookie" && (req.headers["x-khala-local"] !== "1" || req.headers.origin !== void 0 && req.headers.origin !== origin)) return error(res, 403, "forbidden_origin");
+      if (!pathname.startsWith("/api/") && !pathname.startsWith("/open/")) return method === "GET" ? await serveStatic(pathname, res) : error(res, 405, "method_not_allowed");
+      let body;
+      if (method === "POST" || method === "PUT") {
+        if (Number(req.headers["content-length"]) > LOCAL_BODY_LIMIT_BYTES) {
+          res.setHeader("connection", "close");
+          req.resume();
+          return error(res, 413, "payload_too_large");
+        }
+        try {
+          body = await readBody(req, signal);
+        } catch (err) {
+          if (signal.aborted) return;
+          if (err instanceof Error && err.message === "payload_too_large") {
+            res.setHeader("connection", "close");
+            return error(res, 413, "payload_too_large");
+          }
+          return error(res, 400, "invalid_request");
+        }
+      }
+      let matched = false;
+      for (let i = 0; i < options.routes.length; i++) {
+        const route = options.routes[i];
+        route.pattern.lastIndex = 0;
+        const match = route.pattern.exec(pathname);
+        route.pattern.lastIndex = 0;
+        if (!match) continue;
+        matched = true;
+        if (route.method !== method) continue;
+        let params;
+        try {
+          params = match.slice(1).map(decodeURIComponent);
+        } catch {
+          return error(res, 400, "invalid_request");
+        }
+        routeIndex = i;
+        respond(res, await route.handle({ method, path: pathname, query: url.searchParams, headers: req.headers, body, auth, origin, signal }, params, ctx));
+        return;
+      }
+      error(res, matched ? 405 : 404, matched ? "method_not_allowed" : "not_found");
+    } catch (err) {
+      const reason = err instanceof Error ? err.name : "unknown_error";
+      log(JSON.stringify({ at: "route", method: req.method, route: routeIndex, reason }));
+      if (!res.headersSent) error(res, 500, "internal_error");
+    }
+  }
+  return {
+    listen() {
+      if (closing) return Promise.reject(new Error("server_closed"));
+      return listenPromise ??= new Promise((resolve2, reject) => {
+        const fail5 = (err) => {
+          cancelListen = void 0;
+          reject(err);
+        };
+        cancelListen = () => {
+          server.off("error", fail5);
+          reject(new Error("server_closed"));
+        };
+        server.once("error", fail5);
+        server.listen({ host: "127.0.0.1", port: options.port }, () => {
+          server.off("error", fail5);
+          cancelListen = void 0;
+          const address = server.address();
+          if (!address || typeof address === "string") return reject(new Error("invalid_address"));
+          port = address.port;
+          origin = `http://127.0.0.1:${port}`;
+          try {
+            ctx = options.createContext(origin);
+            armIdle();
+            resolve2({ port, origin });
+          } catch (err) {
+            void server.close();
+            reject(err);
+          }
+        });
+      });
+    },
+    close() {
+      if (closePromise) return closePromise;
+      closing = true;
+      clearTimeout(timer);
+      cancelListen?.();
+      cancelListen = void 0;
+      for (const controller of controllers) controller.abort();
+      closePromise = new Promise((resolve2) => {
+        server.close(() => resolve2());
+        server.closeAllConnections();
+      });
+      return closePromise;
+    }
+  };
+}
+
+// src/local/routes/agent-join.ts
+import { createHash as createHash2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
+var sha256hex = (value) => createHash2("sha256").update(value).digest("hex");
+var b64 = (bytes) => Buffer.from(bytes).toString("base64url");
+var fail = (status, error2) => ({ status, json: { error: error2 } });
+function safeEqual(a, b) {
+  const left = Buffer.from(a), right = Buffer.from(b);
+  return left.length === right.length && timingSafeEqual2(left, right);
+}
+function serial() {
+  let tail = Promise.resolve();
+  return (fn) => {
+    const run = tail.then(fn, fn);
+    tail = run.catch(() => void 0);
+    return run;
+  };
+}
+function prune(ctx) {
+  const now = ctx.now();
+  for (const [id, entry] of ctx.joins) if (now >= entry.expiresAt + LOCAL_LINK_TTL_MS) ctx.joins.delete(id);
+}
+function authenticate(req, ctx) {
+  const entries = [...req.query];
+  if (entries.length !== 1 || entries[0][0] !== "joinId" || !/^[A-Za-z0-9_-]{22}$/u.test(entries[0][1])) return null;
+  const header = req.headers.authorization;
+  const bearer = /^Bearer ([^\s]+)$/u.exec((Array.isArray(header) ? header[0] : header) ?? "");
+  const entry = ctx.joins.get(entries[0][1]);
+  return bearer && entry && safeEqual(sha256hex(bearer[1]), entry.pollSecretSha256) ? entry : null;
+}
+function agentJoinRoutes() {
+  const queue = serial();
+  async function create(req, _params, ctx) {
+    try {
+      prune(ctx);
+      if (typeof req.body !== "object" || req.body === null || Array.isArray(req.body)) return fail(400, "invalid_link");
+      const body = req.body;
+      if (!Object.hasOwn(body, "link") || Object.keys(body).some((key) => !["link", "harness", "label"].includes(key))) return fail(400, "invalid_link");
+      if (typeof body.link !== "string" || !parseChannelLink(body.link)) return fail(400, "invalid_link");
+      const harness = body.harness;
+      if (harness !== "claude" && harness !== "codex") return fail(400, "invalid_harness");
+      const url = new URL(body.link);
+      if (url.origin !== ctx.origin && url.origin !== ctx.origin.replace("://127.0.0.1:", "://localhost:")) return fail(404, "link_unavailable");
+      const token = url.pathname.slice("/join/".length);
+      if (!/^[A-Za-z0-9_-]{43}$/u.test(token)) return fail(404, "link_unavailable");
+      const username = ctx.store.owner().username;
+      if (!checkName(defaultAgentName(username, harness, 2), "agent").ok) return fail(503, "unavailable");
+      return await queue(async () => {
+        const link = await ctx.store.consumeLink(token);
+        if (!link || !ctx.store.hasChannel(link.roomId)) return fail(404, "link_unavailable");
+        const roomId = link.roomId;
+        const taken = new Set(ctx.store.members(roomId).map((member) => member.displayName.toLowerCase()));
+        let n = 1;
+        while (taken.has(defaultAgentName(username, harness, n).toLowerCase())) n++;
+        const checked = checkName(defaultAgentName(username, harness, n), "agent");
+        if (!checked.ok) return fail(503, "unavailable");
+        let userId = newLocalAgentUserId(ctx.random(4));
+        for (let attempt = 0; attempt < 5 && ctx.store.channelOfMember(userId) !== void 0; attempt++) userId = newLocalAgentUserId(ctx.random(4));
+        if (ctx.store.channelOfMember(userId) !== void 0) return fail(503, "unavailable");
+        const deviceId = "KH_LOCAL_" + userId.slice("@agent-".length, -":local".length);
+        const accessToken = b64(ctx.random(LOCAL_TOKEN_BYTES));
+        await ctx.store.append(roomId, {
+          type: "m.room.member",
+          sender: LOCAL_OWNER_USER_ID,
+          content: { user: userId, membership: "invite", displayname: checked.name, kind: "agent", harness, invitedBy: LOCAL_OWNER_USER_ID }
+        });
+        await ctx.store.setMemberToken(roomId, userId, sha256hex(accessToken));
+        const joinId = b64(ctx.random(16)), pollSecret = b64(ctx.random(LOCAL_TOKEN_BYTES));
+        const expiresAt = ctx.now() + LOCAL_LINK_TTL_MS;
+        const credentials = { homeserver: ctx.origin, userId, accessToken, deviceId, roomId, transport: "local" };
+        ctx.joins.set(joinId, { joinId, pollSecretSha256: sha256hex(pollSecret), roomId, credentials, state: "confirmed", expiresAt });
+        const result = {
+          joinId,
+          pollSecret,
+          confirmUrl: url.origin + agentConfirmPagePath(joinId),
+          expiresAt: new Date(expiresAt).toISOString(),
+          autoConfirmed: true
+        };
+        return { status: 201, json: result };
+      });
+    } catch {
+      return fail(503, "unavailable");
+    }
+  }
+  async function poll(req, _params, ctx) {
+    prune(ctx);
+    const entry = authenticate(req, ctx);
+    if (!entry) return fail(404, "not_found");
+    if (entry.state === "confirmed" && ctx.now() >= entry.expiresAt) {
+      ctx.joins.delete(entry.joinId);
+      return { status: 200, json: { state: "expired" } };
+    }
+    if (entry.state !== "confirmed") return { status: 200, json: { state: "claimed" } };
+    ctx.joins.set(entry.joinId, { ...entry, state: "claimed", credentials: { ...entry.credentials, accessToken: "" } });
+    return { status: 200, json: { state: "confirmed", credentials: entry.credentials } };
+  }
+  async function ready(req, _params, ctx) {
+    prune(ctx);
+    const entry = authenticate(req, ctx);
+    if (!entry) return fail(404, "not_found");
+    if (entry.state === "confirmed") return fail(409, "not_confirmed");
+    entry.state = "ready";
+    return { status: 204 };
+  }
+  return [
+    { method: "POST", pattern: /^\/api\/agent\/join$/u, handle: create },
+    { method: "GET", pattern: /^\/api\/agent\/join\/poll$/u, handle: poll },
+    { method: "POST", pattern: /^\/api\/agent\/join\/ready$/u, handle: ready }
+  ];
+}
+
+// src/local/routes/rooms.ts
+var fail2 = (status, error2) => ({ status, json: { error: error2 } });
+function serial2() {
+  let tail = Promise.resolve();
+  return (fn) => {
+    const next = tail.then(fn, fn);
+    tail = next.catch(() => void 0);
+    return next;
+  };
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function resolve(req, params, ctx, need) {
+  if (req.auth.kind === "none") return fail2(401, "unauthorized");
+  const userId = req.auth.kind === "owner" ? LOCAL_OWNER_USER_ID : req.auth.userId;
+  let roomId;
+  try {
+    roomId = decodeURIComponent(params[0]);
+  } catch {
+    return fail2(404, "not_found");
+  }
+  if (!ctx.store.hasChannel(roomId)) return fail2(404, "not_found");
+  if (req.auth.kind === "agent" && req.auth.roomId !== roomId) return fail2(403, "not_member");
+  const member = ctx.store.member(roomId, userId);
+  if (!member || need === "present" && member.membership === "leave" || need === "joined" && member.membership !== "join") return fail2(403, "not_member");
+  return { userId, kind: req.auth.kind, roomId, member };
+}
+var announcementTxn = (event) => `local.join.${event.eventId.slice(1)}`;
+function memberEvents(store, roomId, userId) {
+  let after = 0;
+  let current;
+  let joined;
+  let announced = false;
+  for (; ; ) {
+    const page = store.eventsAfter(roomId, after, 200);
+    for (const event of page) {
+      if (event.type === "m.room.member" && event.content["user"] === userId) {
+        if (event.content["membership"] !== "join") {
+          joined = void 0;
+          announced = false;
+        } else if (current?.content["membership"] !== "join") {
+          joined = event;
+          announced = false;
+        }
+        current = event;
+      } else if (joined && event.type === "com.khala.event.v1" && event.sender === LOCAL_OWNER_USER_ID && event.txnId === announcementTxn(joined)) {
+        announced = true;
+      }
+    }
+    if (page.length < 200) return { current, joined, announced };
+    after = page.at(-1).seq;
+  }
+}
+function memberContent(member, extra = {}) {
+  return {
+    user: member.userId,
+    membership: "join",
+    displayname: member.displayName,
+    kind: member.kind,
+    ...member.harness ? { harness: member.harness } : {},
+    ...member.kind === "agent" ? { [LISTENING_MODE_MEMBER_KEY]: member.listeningMode ?? DEFAULT_LISTENING_MODE } : {},
+    ...extra
+  };
+}
+function roomRoutes() {
+  const enqueue = serial2();
+  const route = (method, pattern, need, handle) => ({
+    method,
+    pattern,
+    async handle(req, params, ctx) {
+      try {
+        const caller = resolve(req, params, ctx, need);
+        return "status" in caller ? caller : await handle(req, params, ctx, caller);
+      } catch {
+        return fail2(503, "unavailable");
+      }
+    }
+  });
+  return [
+    route("GET", /^\/api\/local\/rooms\/([^/]+)\/me$/u, "any", async (_req, _params, ctx, caller) => ({
+      status: 200,
+      json: {
+        userId: caller.userId,
+        roomId: caller.roomId,
+        roomName: ctx.store.channelName(caller.roomId),
+        membership: caller.member.membership,
+        displayName: caller.member.displayName,
+        ...caller.kind === "agent" ? { invitedBy: LOCAL_OWNER_USER_ID } : {}
+      }
+    })),
+    route("POST", /^\/api\/local\/rooms\/([^/]+)\/join$/u, "present", async (req, params, ctx) => {
+      if (req.body !== void 0 && (!isPlainObject(req.body) || Object.keys(req.body).length > 0)) return fail2(400, "invalid_request");
+      return enqueue(async () => {
+        const caller = resolve(req, params, ctx, "present");
+        if ("status" in caller) return caller;
+        let event;
+        let joined;
+        let announced = false;
+        if (caller.member.membership === "join") {
+          ({ current: event, joined, announced } = memberEvents(ctx.store, caller.roomId, caller.userId));
+        } else {
+          event = await ctx.store.append(caller.roomId, { type: "m.room.member", sender: caller.userId, content: memberContent(caller.member) });
+          joined = event;
+        }
+        if (caller.kind === "agent" && joined && !announced) {
+          const encoded = encodeChannelEvent({ kind: "member", summary: `${joined.content["displayname"]} joined`, status: "info", source: { system: "khala-local" } });
+          if (encoded.ok) await ctx.store.append(caller.roomId, {
+            type: "com.khala.event.v1",
+            sender: LOCAL_OWNER_USER_ID,
+            content: { ...encoded.value },
+            txnId: announcementTxn(joined)
+          });
+        }
+        return event ? { status: 200, json: { seq: event.seq, ts: event.ts } } : fail2(503, "unavailable");
+      });
+    }),
+    route("GET", /^\/api\/local\/rooms\/([^/]+)\/events$/u, "joined", async (req, params, ctx, caller) => {
+      const rawAfter = req.query.get("after") ?? "0";
+      const rawWait = req.query.get("wait") ?? "0";
+      if (!/^\d{1,15}$/u.test(rawAfter) || !/^\d{1,2}$/u.test(rawWait) || Number(rawWait) > LOCAL_LONG_POLL_MAX_S) return fail2(400, "invalid_request");
+      const after = Number(rawAfter);
+      const wait = Number(rawWait);
+      if (req.signal.aborted) return { status: 200, json: { events: [], next: after } };
+      let events = ctx.store.eventsAfter(caller.roomId, after, 200);
+      if (events.length === 0 && wait > 0) {
+        await ctx.store.waitForEvent(caller.roomId, after, wait * 1e3, req.signal);
+        if (req.signal.aborted) return { status: 200, json: { events: [], next: after } };
+        const current = resolve(req, params, ctx, "joined");
+        if ("status" in current) return current;
+        events = ctx.store.eventsAfter(caller.roomId, after, 200);
+      }
+      return { status: 200, json: { events, next: events.at(-1)?.seq ?? after } };
+    }),
+    route("GET", /^\/api\/local\/rooms\/([^/]+)\/messages$/u, "joined", async (req, _params, ctx, caller) => {
+      const before = req.query.get("before");
+      const limit = req.query.get("limit") ?? "50";
+      if (before !== null && !/^\$[A-Za-z0-9_-]{1,128}$/u.test(before) || !/^\d{1,3}$/u.test(limit) || Number(limit) < 1 || Number(limit) > 100) return fail2(400, "invalid_request");
+      return { status: 200, json: ctx.store.history(caller.roomId, before ?? void 0, Number(limit)) };
+    }),
+    route("POST", /^\/api\/local\/rooms\/([^/]+)\/send$/u, "joined", async (req, params, ctx) => {
+      const decoded = decodeWith(() => {
+        const r = object(req.body, "", ["txnId", "type", "content"]);
+        return { txnId: r.field("txnId"), type: r.field("type"), content: r.field("content") };
+      });
+      if (!decoded.ok) return fail2(400, "invalid_request");
+      const { txnId, type, content } = decoded.value;
+      if (typeof txnId !== "string" || !/^[A-Za-z0-9._-]{1,64}$/u.test(txnId) || type !== "m.room.message" && type !== "com.khala.event.v1" || !isPlainObject(content)) return fail2(400, "invalid_request");
+      if (utf8Length(JSON.stringify(content)) > 32768) return fail2(413, "payload_too_large");
+      let stored = content;
+      if (type === "m.room.message") {
+        if (content["msgtype"] !== "m.text" && content["msgtype"] !== "m.notice" || typeof content["body"] !== "string" || content["body"].length < 1 || content["body"].length > 8e3) return fail2(400, "invalid_request");
+      } else {
+        const event = decodeChannelEvent(content);
+        if (!event.ok) return fail2(400, "invalid_request");
+        stored = { ...event.value };
+      }
+      return enqueue(async () => {
+        const caller = resolve(req, params, ctx, "joined");
+        if ("status" in caller) return caller;
+        const event = await ctx.store.append(caller.roomId, { type, sender: caller.userId, content: stored, txnId });
+        return { status: 200, json: { eventId: event.eventId } };
+      });
+    }),
+    route("GET", /^\/api\/local\/rooms\/([^/]+)\/members$/u, "joined", async (_req, _params, ctx, caller) => ({
+      status: 200,
+      json: { members: ctx.store.members(caller.roomId) }
+    })),
+    route("PUT", /^\/api\/local\/rooms\/([^/]+)\/members\/([^/]+)$/u, "joined", async (req, params, ctx, caller) => {
+      let target;
+      try {
+        target = decodeURIComponent(params[1]);
+      } catch {
+        return fail2(400, "invalid_request");
+      }
+      if (caller.kind !== "agent" || target !== caller.userId) return fail2(409, "conflict");
+      const body = decodeWith(() => object(req.body, "", ["listeningMode"]).field("listeningMode"));
+      const mode = decodeListeningMode(body.ok ? body.value : void 0);
+      if (!body.ok || !mode.ok) return fail2(400, "invalid_request");
+      return enqueue(async () => {
+        const current = resolve(req, params, ctx, "joined");
+        if ("status" in current) return current;
+        await ctx.store.append(current.roomId, {
+          type: "m.room.member",
+          sender: current.userId,
+          content: memberContent(current.member, { [LISTENING_MODE_MEMBER_KEY]: mode.value })
+        });
+        return { status: 204 };
+      });
+    })
+  ];
+}
+
+// src/local/routes/owner.ts
+var ID = /^[A-Za-z0-9._-]{1,64}$/u;
+var USER = /^@[^\s:]+:\S+$/u;
+var fail3 = (status, error2) => ({ status, json: { error: error2 } });
+function serial3() {
+  let tail = Promise.resolve();
+  return (work) => {
+    const result = tail.then(work);
+    tail = result.then(() => void 0, () => void 0);
+    return result;
+  };
+}
+function owner(req, adminOnly) {
+  if (req.auth.kind === "none") return fail3(401, "unauthorized");
+  if (req.auth.kind !== "owner" || adminOnly && req.auth.via !== "admin") return fail3(403, "forbidden");
+  return null;
+}
+function plainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function decodeParam(raw) {
+  if (raw === void 0) return null;
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    return null;
+  }
+}
+function channelParam(raw, store) {
+  const id = decodeParam(raw);
+  return id !== null && store.hasChannel(id) ? id : null;
+}
+function memberContent2(member, membership, overrides = {}) {
+  return {
+    user: member.userId,
+    membership,
+    displayname: member.displayName,
+    kind: member.kind,
+    ...member.harness ? { harness: member.harness } : {},
+    ...member.kind === "agent" ? { [LISTENING_MODE_MEMBER_KEY]: member.listeningMode ?? DEFAULT_LISTENING_MODE } : {},
+    ...overrides
+  };
+}
+async function announce(store, roomId, summary) {
+  const encoded = encodeChannelEvent({ kind: "member", summary, status: "info", source: { system: "khala-local" } });
+  if (encoded.ok) await store.append(roomId, { type: CHANNEL_EVENT_TYPE, sender: LOCAL_OWNER_USER_ID, content: encoded.value });
+}
+function ownerRoutes(options = {}) {
+  const queue = options.queue ?? serial3();
+  function route(method, pattern, handler, options2 = {}) {
+    return { method, pattern, async handle(req, params, ctx) {
+      try {
+        if (!options2.public) {
+          const denied = owner(req, options2.adminOnly ?? false);
+          if (denied) return denied;
+        }
+        return await (options2.serial ? queue(() => handler(req, params, ctx)) : handler(req, params, ctx));
+      } catch {
+        return fail3(503, "unavailable");
+      }
+    } };
+  }
+  return [
+    route("GET", /^\/api\/local\/channels$/u, async (req, _params, { store }) => {
+      const since = req.query.get("since");
+      const wait = req.query.get("wait") ?? "0";
+      if (since !== null && !/^\d{1,15}$/u.test(since) || !/^\d{1,2}$/u.test(wait) || Number(wait) > LOCAL_LONG_POLL_MAX_S) return fail3(400, "invalid_request");
+      if (since !== null && Number(since) === store.revision() && Number(wait) > 0) await store.waitForRevision(Number(since), Number(wait) * 1e3, req.signal);
+      return { status: 200, json: { revision: store.revision(), channels: store.listChannels() } };
+    }),
+    route("GET", /^\/api\/local\/channels\/by-operation\/([^/]+)$/u, async (_req, params, { store }) => {
+      const id = decodeParam(params[0]);
+      if (id === null || !ID.test(id)) return fail3(404, "not_found");
+      const roomId = store.findByOperation(id);
+      return roomId === void 0 ? fail3(404, "not_found") : { status: 200, json: { roomId } };
+    }),
+    route("GET", /^\/api\/local\/channels\/([^/]+)$/u, async (_req, params, { store }) => {
+      const roomId = channelParam(params[0], store);
+      const summary = roomId === null ? void 0 : store.channelSummary(roomId);
+      return summary === void 0 ? fail3(404, "not_found") : { status: 200, json: summary };
+    }),
+    route("POST", /^\/api\/local\/channels$/u, async (req, _params, ctx) => {
+      const body = req.body;
+      if (!plainObject(body) || !Object.hasOwn(body, "name") || Object.keys(body).some((key) => key !== "name" && key !== "operationId") || typeof body.name !== "string") return fail3(400, "invalid_request");
+      const name = body.name.trim();
+      if ([...name].length < 1 || [...name].length > 64 || /[\u0000-\u001f\u007f]/u.test(name)) return fail3(400, "invalid_request");
+      if (Object.hasOwn(body, "operationId") && (typeof body.operationId !== "string" || !ID.test(body.operationId))) return fail3(400, "invalid_request");
+      const { store } = ctx;
+      const { roomId } = await store.createChannel(name, body.operationId);
+      if (store.member(roomId, LOCAL_OWNER_USER_ID)?.membership !== "join") await store.append(roomId, {
+        type: "m.room.member",
+        sender: LOCAL_OWNER_USER_ID,
+        content: { user: LOCAL_OWNER_USER_ID, membership: "join", displayname: store.owner().username, kind: "human" }
+      });
+      const self = await store.mintLink(roomId, "join");
+      const share = await store.mintLink(roomId, "join");
+      const open2 = ctx.mintOpenToken(roomId);
+      return { status: 201, json: { roomId, name: store.channelName(roomId), selfLink: `${ctx.origin}/join/${self.token}`, shareLink: `${ctx.origin}/join/${share.token}`, openUrl: `${ctx.origin}/open/${open2.token}`, expiresAt: self.expiresAt } };
+    }, { serial: true }),
+    route("DELETE", /^\/api\/local\/channels\/([^/]+)$/u, async (_req, params, ctx) => {
+      const roomId = channelParam(params[0], ctx.store);
+      if (roomId === null) return fail3(404, "not_found");
+      await ctx.store.deleteChannel(roomId);
+      for (const [id, join] of ctx.joins) if (join.roomId === roomId) ctx.joins.delete(id);
+      return { status: 204 };
+    }, { serial: true }),
+    route("POST", /^\/api\/local\/channels\/([^/]+)\/links$/u, async (_req, params, ctx) => {
+      const roomId = channelParam(params[0], ctx.store);
+      if (roomId === null) return fail3(404, "not_found");
+      const link = await ctx.store.mintLink(roomId, "join");
+      return { status: 200, json: { shareLink: `${ctx.origin}/join/${link.token}`, expiresAt: link.expiresAt } };
+    }, { serial: true }),
+    route("POST", /^\/api\/local\/channels\/([^/]+)\/mode$/u, async (req, params, { store }) => {
+      const roomId = channelParam(params[0], store);
+      if (roomId === null) return fail3(404, "not_found");
+      const body = decodeWith(() => {
+        const reader = object(req.body, "", ["agent", "mode", "txnId"]);
+        return { agent: reader.field("agent"), mode: reader.field("mode"), txnId: reader.field("txnId") };
+      });
+      if (!body.ok || typeof body.value.txnId !== "string" || !ID.test(body.value.txnId)) return fail3(400, "invalid_request");
+      const command = decodeListeningModeCommand({ v: 1, agent: body.value.agent, mode: body.value.mode });
+      if (!command.ok) return fail3(400, "invalid_request");
+      const member = store.member(roomId, command.value.agent);
+      if (!member || member.membership === "leave" || member.kind !== "agent") return fail3(404, "not_found");
+      const event = await store.append(roomId, { type: LISTENING_MODE_COMMAND_TYPE, sender: LOCAL_OWNER_USER_ID, content: command.value, txnId: body.value.txnId });
+      return { status: 200, json: { eventId: event.eventId } };
+    }, { serial: true }),
+    route("POST", /^\/api\/local\/agents\/([^/]+)\/name$/u, async (req, params, { store }) => {
+      const userId = decodeParam(params[0]);
+      if (userId === null || !USER.test(userId)) return fail3(400, "invalid_request");
+      const body = decodeWith(() => object(req.body, "", ["name"]).field("name"));
+      if (!body.ok || typeof body.value !== "string") return fail3(400, "invalid_request");
+      const checked = checkName(body.value, "agent");
+      if (!checked.ok) return { status: 400, json: { error: "invalid_name", reason: checked.error } };
+      const roomId = store.channelOfMember(userId);
+      if (roomId === void 0) return fail3(404, "not_found");
+      const member = store.member(roomId, userId);
+      if (!member || member.membership === "leave" || member.kind !== "agent") return fail3(404, "not_found");
+      if (store.members(roomId).some((other) => other.userId !== userId && other.displayName.toLowerCase() === checked.name.toLowerCase())) return fail3(409, "name_taken");
+      if (member.displayName !== checked.name) await store.append(roomId, { type: "m.room.member", sender: LOCAL_OWNER_USER_ID, content: memberContent2(member, member.membership, { displayname: checked.name }) });
+      return { status: 200, json: { matrixUserId: userId, name: checked.name } };
+    }, { serial: true }),
+    route("DELETE", /^\/api\/local\/channels\/([^/]+)\/members\/([^/]+)$/u, async (_req, params, ctx) => {
+      const roomId = channelParam(params[0], ctx.store);
+      if (roomId === null) return fail3(404, "not_found");
+      const userId = decodeParam(params[1]);
+      if (userId === null || !USER.test(userId) || userId === LOCAL_OWNER_USER_ID) return fail3(400, "invalid_request");
+      const member = ctx.store.member(roomId, userId);
+      if (!member || member.membership === "leave") return fail3(404, "not_found");
+      await ctx.store.append(roomId, { type: "m.room.member", sender: LOCAL_OWNER_USER_ID, content: memberContent2(member, "leave") });
+      await announce(ctx.store, roomId, `${member.displayName} left`);
+      for (const [id, join] of ctx.joins) if (join.credentials.userId === userId) ctx.joins.delete(id);
+      return { status: 204 };
+    }, { serial: true }),
+    route("POST", /^\/api\/local\/open$/u, async (req, _params, ctx) => {
+      const body = req.body === void 0 ? {} : req.body;
+      if (!plainObject(body) || Object.keys(body).some((key) => key !== "roomId") || Object.hasOwn(body, "roomId") && typeof body.roomId !== "string") return fail3(400, "invalid_request");
+      const roomId = body.roomId;
+      if (roomId !== void 0 && !ctx.store.hasChannel(roomId)) return fail3(404, "not_found");
+      const link = ctx.mintOpenToken(roomId);
+      return { status: 200, json: { openUrl: `${ctx.origin}/open/${link.token}`, expiresAt: link.expiresAt } };
+    }, { adminOnly: true }),
+    route("GET", /^\/open\/([A-Za-z0-9_-]{43})$/u, async (_req, params, ctx) => {
+      const opened = ctx.consumeOpenToken(params[0]);
+      if (opened === null) return fail3(404, "link_unavailable");
+      const sid = ctx.createOwnerSession();
+      const location = opened.roomId && ctx.store.hasChannel(opened.roomId) ? `/channels/${encodeURIComponent(opened.roomId)}` : "/conversations";
+      return { status: 302, location, headers: { "set-cookie": `khala_local_owner=${sid}; HttpOnly; SameSite=Strict; Path=/`, "cache-control": "no-store", "referrer-policy": "no-referrer" } };
+    }, { public: true }),
+    route("POST", /^\/api\/local\/shutdown$/u, async (_req, _params, ctx) => {
+      ctx.shutdown();
+      return { status: 204 };
+    }, { adminOnly: true })
+  ];
+}
+
+// src/local/routes/profile.ts
+var fail4 = (status, error2) => ({ status, json: { error: error2 } });
+var field = (body, key) => decodeWith(() => object(body, "", [key]).field(key));
+var iso = (ctx) => new Date(ctx.now()).toISOString();
+async function cascade(store, previous, next) {
+  for (const { roomId } of store.listChannels()) {
+    try {
+      const members = store.members(roomId);
+      const taken = new Set(members.map((m) => m.displayName.toLowerCase()));
+      const owner2 = members.find((m) => m.userId === LOCAL_OWNER_USER_ID);
+      if (owner2 && owner2.displayName !== next) {
+        try {
+          await store.append(roomId, {
+            type: "m.room.member",
+            sender: LOCAL_OWNER_USER_ID,
+            content: { user: LOCAL_OWNER_USER_ID, membership: owner2.membership, displayname: next, kind: "human" }
+          });
+          taken.delete(owner2.displayName.toLowerCase());
+          taken.add(next.toLowerCase());
+        } catch {
+        }
+      }
+      for (const m of members) {
+        if (m.kind !== "agent" || !m.harness || !isDefaultAgentName(m.displayName, previous, m.harness)) continue;
+        const n = Number(/-(\d+)$/u.exec(m.displayName)?.[1] ?? 1);
+        if (!Number.isSafeInteger(n) || n < 1) continue;
+        const oldKey = m.displayName.toLowerCase();
+        taken.delete(oldKey);
+        try {
+          let name = defaultAgentName(next, m.harness, n);
+          if (taken.has(name.toLowerCase())) {
+            let k = 1;
+            do {
+              name = defaultAgentName(next, m.harness, k++);
+            } while (taken.has(name.toLowerCase()));
+          }
+          if (!checkName(name, "agent").ok) {
+            taken.add(oldKey);
+            continue;
+          }
+          if (name !== m.displayName) {
+            await store.append(roomId, {
+              type: "m.room.member",
+              sender: LOCAL_OWNER_USER_ID,
+              content: {
+                user: m.userId,
+                membership: m.membership,
+                displayname: name,
+                kind: "agent",
+                harness: m.harness,
+                [LISTENING_MODE_MEMBER_KEY]: m.listeningMode ?? DEFAULT_LISTENING_MODE
+              }
+            });
+          }
+          taken.add(name.toLowerCase());
+        } catch {
+          taken.add(oldKey);
+        }
+      }
+    } catch {
+    }
+  }
+}
+function profileRoutes(options = {}) {
+  const queue = options.queue ?? serial3();
+  const route = (method, pattern, run) => ({
+    method,
+    pattern,
+    async handle(req, _params, ctx) {
+      if (req.auth.kind === "none") return fail4(401, "unauthorized");
+      if (req.auth.kind === "agent") return fail4(403, "forbidden");
+      try {
+        return await queue(() => run(req, ctx));
+      } catch {
+        return fail4(503, "unavailable");
+      }
+    }
+  });
+  return [
+    route("GET", /^\/api\/local\/profile$/u, async (_req, ctx) => {
+      const p = ctx.store.owner();
+      const profile = {
+        userId: LOCAL_OWNER_USER_ID,
+        ownerId: LOCAL_OWNER_ID,
+        username: p.username,
+        suggestion: p.username,
+        color: p.color,
+        initials: p.initials
+      };
+      return { status: 200, json: profile };
+    }),
+    route("POST", /^\/api\/local\/profile\/username$/u, async (req, ctx) => {
+      const parsed = field(req.body, "username");
+      if (!parsed.ok) return fail4(400, "invalid_request");
+      const checked = checkName(parsed.value, "username");
+      if (!checked.ok) return { status: 400, json: { error: "invalid_username", reason: checked.error } };
+      const username = checked.name;
+      const p = ctx.store.owner();
+      if (p.username !== username) {
+        await ctx.store.setOwner({ ...p, username, updatedAt: iso(ctx) });
+        try {
+          await cascade(ctx.store, p.username, username);
+        } catch {
+        }
+      }
+      return { status: 200, json: { username } };
+    }),
+    route("POST", /^\/api\/local\/profile\/color$/u, async (req, ctx) => {
+      const parsed = field(req.body, "color");
+      if (!parsed.ok) return fail4(400, "invalid_request");
+      if (!isHumanColorId(parsed.value)) return fail4(400, "invalid_color");
+      const color = parsed.value;
+      const p = ctx.store.owner();
+      if (p.color !== color) await ctx.store.setOwner({ ...p, color, updatedAt: iso(ctx) });
+      return { status: 200, json: { color } };
+    }),
+    route("POST", /^\/api\/local\/profile\/initials$/u, async (req, ctx) => {
+      const parsed = field(req.body, "initials");
+      if (!parsed.ok) return fail4(400, "invalid_request");
+      const initials = parsed.value === null ? null : normalizeInitials(parsed.value);
+      if (parsed.value !== null && initials === null) return fail4(400, "invalid_initials");
+      const p = ctx.store.owner();
+      if (p.initials !== initials) await ctx.store.setOwner({ ...p, initials, updatedAt: iso(ctx) });
+      return { status: 200, json: { initials } };
+    })
+  ];
+}
+
+// src/local/serve.ts
+function defaultWebDir() {
+  return fileURLToPath(bundle ? new URL("./web/", import.meta.url) : new URL("../../../../apps/web/dist-local/", import.meta.url));
+}
+var hash = (token) => createHash3("sha256").update(token).digest();
+async function runHelper(options = {}) {
+  const env = options.env ?? process.env;
+  const now = options.now ?? Date.now;
+  const random = options.random ?? randomBytes2;
+  const stderr = options.stderr ?? ((line) => {
+    process.stderr.write(line);
+  });
+  let store;
+  let server;
+  let boundPort;
+  let stop;
+  const stopped = new Promise((resolve2) => {
+    stop = resolve2;
+  });
+  let shutdownTimer;
+  try {
+    const paths = helperPaths(env);
+    const port = options.port ?? paths.port;
+    const idleValue = env.KHALA_LOCAL_IDLE_MS;
+    const idleMs = options.idleMs ?? (idleValue && /^\d+$/u.test(idleValue) && Number.isSafeInteger(Number(idleValue)) && Number(idleValue) > 0 ? Number(idleValue) : LOCAL_IDLE_EXIT_MS);
+    const webDir = options.webDir ?? (env.KHALA_LOCAL_WEB_DIR && path3.isAbsolute(env.KHALA_LOCAL_WEB_DIR) ? env.KHALA_LOCAL_WEB_DIR : defaultWebDir());
+    store = await openLocalStore({ root: paths.root, ownerDefault: {
+      v: 1,
+      initials: null,
+      username: await resolveLocalOwnerName(env),
+      color: defaultHumanColor(LOCAL_OWNER_USER_ID),
+      updatedAt: new Date(now()).toISOString()
+    }, now, random });
+    const localStore = store;
+    const adminToken = base64url(random(32));
+    const adminHash = hash(adminToken);
+    const sessions = /* @__PURE__ */ new Set();
+    const openTokens = /* @__PURE__ */ new Map();
+    const queue = serial3();
+    server = createHelperServer({
+      port,
+      webDir,
+      idleMs,
+      onIdle: stop,
+      routes: [...agentJoinRoutes(), ...roomRoutes(), ...ownerRoutes({ queue }), ...profileRoutes({ queue })],
+      authenticateCookie: (value) => sessions.has(value),
+      authenticateBearer: (token) => {
+        if (timingSafeEqual3(hash(token), adminHash)) return { kind: "owner", via: "admin" };
+        const agent = localStore.agentForToken(token);
+        return agent ? { kind: "agent", ...agent } : { kind: "none" };
+      },
+      createContext: (origin) => ({
+        store: localStore,
+        origin,
+        now,
+        random,
+        version: KHALA_AGENT_VERSION,
+        joins: /* @__PURE__ */ new Map(),
+        mintOpenToken(roomId) {
+          const token = base64url(random(32));
+          const expiresAt = now() + LOCAL_LINK_TTL_MS;
+          openTokens.set(hash(token).toString("hex"), { ...roomId === void 0 ? {} : { roomId }, expiresAt });
+          return { token, expiresAt: new Date(expiresAt).toISOString() };
+        },
+        consumeOpenToken(token) {
+          const key = hash(token).toString("hex");
+          const entry = openTokens.get(key);
+          openTokens.delete(key);
+          return !entry || entry.expiresAt <= now() ? null : entry.roomId === void 0 ? {} : { roomId: entry.roomId };
+        },
+        createOwnerSession() {
+          const token = base64url(random(32));
+          sessions.add(token);
+          return token;
+        },
+        shutdown() {
+          shutdownTimer ??= setTimeout(stop, 25);
+        }
+      })
+    });
+    let bound;
+    try {
+      bound = await server.listen();
+    } catch (error2) {
+      await store.close();
+      if (error2.code === "EADDRINUSE") {
+        try {
+          const response = await fetch(`http://127.0.0.1:${port}/healthz`, { signal: AbortSignal.timeout(500) });
+          if (response.status === 200 && (await response.json()).ok === true) return 0;
+          await response.body?.cancel();
+        } catch {
+        }
+        stderr('{"error":"port_in_use"}\n');
+      } else stderr('{"error":"listen_failed"}\n');
+      return 1;
+    }
+    boundPort = bound.port;
+    process.once("SIGTERM", stop);
+    process.once("SIGINT", stop);
+    options.signal?.addEventListener("abort", stop, { once: true });
+    if (options.signal?.aborted) stop();
+    await store.setOwner(store.owner());
+    await writeJsonAtomic(paths.helperFile, { v: 1, pid: process.pid, ...bound, adminToken, version: KHALA_AGENT_VERSION, startedAt: new Date(now()).toISOString() });
+    await stopped;
+    return 0;
+  } catch (error2) {
+    stderr(JSON.stringify({ error: error2 instanceof StateError || error2 instanceof LocalStoreError ? error2.code : "internal_error" }) + "\n");
+    return 1;
+  } finally {
+    process.off("SIGTERM", stop);
+    process.off("SIGINT", stop);
+    options.signal?.removeEventListener("abort", stop);
+    if (shutdownTimer) clearTimeout(shutdownTimer);
+    let cleanupFailed = false;
+    try {
+      await server?.close();
+    } catch {
+      cleanupFailed = true;
+    }
+    try {
+      await store?.close();
+    } catch {
+      cleanupFailed = true;
+    }
+    try {
+      if (boundPort !== void 0) {
+        const file = await readHelperFile(env);
+        if (file?.pid === process.pid && file.port === boundPort) await unlink(helperPaths(env).helperFile);
+      }
+    } catch {
+      cleanupFailed = true;
+    }
+    if (cleanupFailed) {
+      stderr('{"error":"storage_failed"}\n');
+      return 1;
+    }
+  }
+}
+
+// src/local/cli.ts
+var CliError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+  code;
+};
+var arities = {
+  create: [0, 1],
+  link: [1, 1],
+  open: [0, 1],
+  list: [0, 0],
+  delete: [1, 1],
+  status: [0, 0],
+  stop: [0, 0],
+  serve: [0, 0]
+};
+async function runLocalCommand(argv, deps = {}) {
+  const env = deps.env ?? process.env;
+  const stdout = deps.stdout ?? ((line) => {
+    process.stdout.write(line);
+  });
+  const stderr = deps.stderr ?? ((line) => {
+    process.stderr.write(line);
+  });
+  const fetchImpl = deps.fetch ?? globalThis.fetch;
+  const now = deps.now ?? Date.now;
+  const print = (value) => stdout(JSON.stringify(value) + "\n");
+  async function health(file) {
+    try {
+      const response = await fetchImpl(file.origin + "/healthz", { signal: AbortSignal.timeout(500) });
+      if (response.status !== 200) {
+        await response.body?.cancel();
+        return null;
+      }
+      const body = await response.json();
+      return body?.ok === true && body.pid === file.pid && typeof body.version === "string" ? body : null;
+    } catch {
+      return null;
+    }
+  }
+  try {
+    const [command = "", ...args] = argv;
+    const arity = arities[command];
+    if (!arity || args.length < arity[0] || args.length > arity[1]) throw new CliError("invalid_arguments");
+    if (command === "serve") return await (deps.serve ?? runHelper)({ env });
+    let connection;
+    let file = null;
+    let healthy = null;
+    if (command === "status" || command === "stop") {
+      file = await (deps.readHelperFile ?? readHelperFile)(env);
+      healthy = file ? await health(file) : null;
+      if (!file || !healthy) {
+        print(command === "status" ? { running: false } : { stopped: false });
+        return 0;
+      }
+      connection = file;
+    } else {
+      try {
+        connection = await (deps.ensureHelper ?? ensureHelper)(env);
+      } catch (error2) {
+        throw error2 instanceof StateError ? error2 : new CliError("helper_unavailable");
+      }
+    }
+    async function call(method, endpoint, body) {
+      let response;
+      try {
+        response = await fetchImpl(connection.origin + endpoint, {
+          method,
+          headers: { authorization: `Bearer ${connection.adminToken}`, ...body === void 0 ? {} : { "content-type": "application/json" } },
+          ...body === void 0 ? {} : { body: JSON.stringify(body) },
+          signal: AbortSignal.timeout(5e3)
+        });
+      } catch {
+        throw new CliError("helper_unavailable");
+      }
+      if (response.status === 204) return null;
+      let value;
+      try {
+        value = await response.json();
+      } catch {
+        throw new CliError(response.status === 404 ? "not_found" : "internal_error");
+      }
+      if (!response.ok) throw new CliError(response.status === 404 ? "not_found" : typeof value === "object" && value !== null && "error" in value && typeof value.error === "string" ? value.error : "internal_error");
+      if (typeof value !== "object" || value === null || Array.isArray(value)) throw new CliError("internal_error");
+      return value;
+    }
+    async function channels() {
+      const page = await call("GET", "/api/local/channels");
+      if (!Array.isArray(page?.channels)) throw new CliError("internal_error");
+      return page.channels;
+    }
+    async function resolveChannel(arg) {
+      if (isLocalRoomId(arg)) return arg;
+      const matches = (await channels()).filter((channel) => channel.name === arg);
+      if (matches.length !== 1) throw new CliError(matches.length ? "ambiguous_channel" : "not_found");
+      return matches[0].roomId;
+    }
+    async function webHint() {
+      try {
+        const response = await fetchImpl(connection.origin + "/", { signal: AbortSignal.timeout(500) });
+        if (response.status === 503 && (await response.json()).error === "web_not_built") stderr("khala: web app not built; run pnpm --filter @khala/web build:local\n");
+        else await response.body?.cancel();
+      } catch {
+      }
+    }
+    let result;
+    switch (command) {
+      case "create": {
+        const date = new Date(now());
+        const name = args[0] ?? `local-${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+        result = await call("POST", "/api/local/channels", { name });
+        await webHint();
+        break;
+      }
+      case "link":
+        result = await call("POST", `/api/local/channels/${encodeURIComponent(await resolveChannel(args[0]))}/links`);
+        break;
+      case "open":
+        result = await call("POST", "/api/local/open", args[0] === void 0 ? {} : { roomId: await resolveChannel(args[0]) });
+        await webHint();
+        break;
+      case "list":
+        result = { channels: await channels() };
+        break;
+      case "delete": {
+        const roomId = await resolveChannel(args[0]);
+        await call("DELETE", `/api/local/channels/${encodeURIComponent(roomId)}`);
+        result = { deleted: roomId };
+        break;
+      }
+      case "status":
+        result = { running: true, origin: file.origin, pid: file.pid, version: healthy.version, channels: (await channels()).length };
+        break;
+      case "stop": {
+        if (await call("POST", "/api/local/shutdown") !== null) throw new CliError("internal_error");
+        const deadline = now() + 2e3;
+        for (let attempt = 0; attempt < 20 && now() < deadline; attempt++) {
+          if (!await health(file)) break;
+          await (deps.sleep ?? sleepDefault)(100);
+        }
+        result = { stopped: true };
+        break;
+      }
+    }
+    print(result);
+    return 0;
+  } catch (error2) {
+    print({ error: error2 instanceof CliError || error2 instanceof StateError ? error2.code : "internal_error" });
+    return 1;
+  }
+}
+async function main(argv) {
+  const code = await runLocalCommand(argv);
+  if (argv.length === 1 && argv[0] === "serve") setImmediate(() => process.exit(code));
+  return code;
+}
+export {
+  main as default,
+  runLocalCommand
+};