khala-cli 0.3.0

package/dist/chunk-ZRUF3P53.mjs

@@ -0,0 +1,557 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  KhalaClientError,
+  checkName,
+  readHumanColorId,
+  readHumanInitials
+} from "./chunk-6GOETMWV.mjs";
+import {
+  StateError,
+  ensureStateDir,
+  readJson,
+  stateRoot
+} from "./chunk-S6XASSNU.mjs";
+import {
+  LISTENING_MODES,
+  M1_LABEL_MAX_BYTES,
+  array,
+  decodeWith,
+  displayText,
+  elementPath,
+  fail,
+  identifier,
+  literal,
+  nullable,
+  object,
+  readHarness,
+  readHttpUrl,
+  readMatrixUserId,
+  readRoomId,
+  safeInteger,
+  text,
+  utcTimestamp,
+  utf8Length,
+  version
+} from "./chunk-GO5DD2TR.mjs";
+import {
+  bundle
+} from "./chunk-HMGN52QY.mjs";
+
+// ../contracts/src/m1/local.ts
+var LOCAL_OWNER_USER_ID = "@khala_owner:local";
+var LOCAL_DEFAULT_PORT = 47830;
+var LOCAL_LINK_TTL_MS = 6e5;
+var LOCAL_LONG_POLL_MAX_S = 25;
+var LOCAL_IDLE_EXIT_MS = 6e5;
+var LOCAL_TOKEN_BYTES = 32;
+var LOCAL_CHANNEL_NAME_MAX_CHARS = 64;
+var LOCAL_BODY_MAX_CHARS = 8e3;
+var LOCAL_CONTENT_MAX_BYTES = 32768;
+var LOCAL_EVENTS_PAGE_MAX = 200;
+var LOCAL_HISTORY_LIMIT_MAX = 100;
+var LOCAL_MEMBERS_MAX = 100;
+var LOCAL_AGENT_DEVICE_PREFIX = "KH_LOCAL_";
+function base64url(bytes) {
+  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+  let result = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const n = bytes[i] << 16 | (bytes[i + 1] ?? 0) << 8 | (bytes[i + 2] ?? 0);
+    result += alphabet[n >> 18 & 63] + alphabet[n >> 12 & 63];
+    if (i + 1 < bytes.length) result += alphabet[n >> 6 & 63];
+    if (i + 2 < bytes.length) result += alphabet[n & 63];
+  }
+  return result;
+}
+function hex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function exact(bytes, n) {
+  if (bytes.length !== n) throw new RangeError("random_length");
+  return bytes;
+}
+var newLocalRoomId = (random16) => `!${base64url(exact(random16, 16))}:local`;
+var newLocalAgentUserId = (random4) => `@agent-${hex(exact(random4, 4))}:local`;
+var newLocalEventId = (random16) => `$${base64url(exact(random16, 16))}`;
+var isLocalRoomId = (value) => /^![A-Za-z0-9_-]{22}:local$/u.test(value);
+var isLocalAgentUserId = (value) => /^@agent-[0-9a-f]{8}:local$/u.test(value);
+var isLocalUserId = (value) => value === LOCAL_OWNER_USER_ID || isLocalAgentUserId(value);
+var isLocalEventId = (value) => /^\$[A-Za-z0-9_-]{22}$/u.test(value);
+var isLocalTxnId = (value) => /^[A-Za-z0-9._-]{1,64}$/u.test(value);
+var localRoomKey = (roomId) => {
+  if (!isLocalRoomId(roomId)) throw new RangeError("not_local_room");
+  return roomId.slice(1, -":local".length);
+};
+var localRoomPath = (roomId, tail) => `/api/local/rooms/${encodeURIComponent(roomId)}/${tail}`;
+var LOCAL_OWNER_ID = "local-owner";
+var LOCAL_OWNER_DEVICE_ID = "KH_LOCAL_OWNER";
+function readLocalRoomId(input, path2) {
+  const value = readRoomId(input, path2);
+  if (!isLocalRoomId(value)) fail(path2, "invalid_value");
+  return value;
+}
+function readLocalUserId(input, path2) {
+  const value = readMatrixUserId(input, path2);
+  if (!isLocalUserId(value)) fail(path2, "invalid_value");
+  return value;
+}
+function readLocalEventId(input, path2) {
+  const value = identifier(input, path2);
+  if (!isLocalEventId(value)) fail(path2, "invalid_value");
+  return value;
+}
+function readLocalTxnId(input, path2) {
+  const value = identifier(input, path2);
+  if (!isLocalTxnId(value)) fail(path2, "invalid_value");
+  return value;
+}
+function readLocalUsername(input, path2) {
+  const value = identifier(input, path2);
+  const checked = checkName(value, "username");
+  if (!checked.ok || checked.name !== value) fail(path2, "invalid_value");
+  return value;
+}
+function readLocalInitials(input, path2) {
+  return readHumanInitials(input, path2);
+}
+function record(input, path2, required, optional = []) {
+  const present = optional.filter((key) => typeof input === "object" && input !== null && Object.hasOwn(input, key));
+  return object(input, path2, [...required, ...present]);
+}
+function has(input, key) {
+  return typeof input === "object" && input !== null && Object.hasOwn(input, key);
+}
+function plainObject(input, path2) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) fail(path2, "not_object");
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== Object.prototype && prototype !== null) fail(path2, "not_object");
+  return input;
+}
+function contentObject(input, path2) {
+  const value = plainObject(input, path2);
+  let encoded;
+  try {
+    encoded = JSON.stringify(value);
+  } catch {
+    fail(path2, "invalid_value");
+  }
+  if (utf8Length(encoded) > LOCAL_CONTENT_MAX_BYTES) fail(path2, "too_long");
+  return value;
+}
+function channelName(input, path2) {
+  const value = displayName(input, path2);
+  if ([...value].length > LOCAL_CHANNEL_NAME_MAX_CHARS) fail(path2, "too_long");
+  if (value !== value.trim()) fail(path2, "invalid_value");
+  return value;
+}
+function displayName(input, path2) {
+  const value = displayText(input, path2, M1_LABEL_MAX_BYTES);
+  if (value.length === 0) fail(path2, "empty");
+  return value;
+}
+function seq(input, path2) {
+  const value = safeInteger(input, path2);
+  if (value === 0) fail(path2, "invalid_value");
+  return value;
+}
+function readCreateContent(input, path2) {
+  const r = record(input, path2, ["name", "createdBy"], ["operationId"]);
+  return {
+    name: channelName(r.field("name"), r.at("name")),
+    createdBy: readLocalUserId(r.field("createdBy"), r.at("createdBy")),
+    ...has(input, "operationId") ? { operationId: readLocalTxnId(r.field("operationId"), r.at("operationId")) } : {}
+  };
+}
+function readNameContent(input, path2) {
+  const r = object(input, path2, ["name"]);
+  return { name: channelName(r.field("name"), r.at("name")) };
+}
+function readMemberContent(input, path2) {
+  const modeKey = "com.khala.listening_mode";
+  const r = record(input, path2, ["user", "membership", "displayname", "kind"], ["harness", "invitedBy", modeKey]);
+  const kind = literal(r.field("kind"), r.at("kind"), ["human", "agent"]);
+  if (kind === "human") {
+    for (const key of ["harness", modeKey]) if (has(input, key)) fail(r.at(key), "invalid_value");
+  }
+  return {
+    user: readLocalUserId(r.field("user"), r.at("user")),
+    membership: literal(r.field("membership"), r.at("membership"), ["invite", "join", "leave"]),
+    displayname: displayName(r.field("displayname"), r.at("displayname")),
+    kind,
+    ...has(input, "harness") ? { harness: readHarness(r.field("harness"), r.at("harness")) } : {},
+    ...has(input, "invitedBy") ? { invitedBy: readLocalUserId(r.field("invitedBy"), r.at("invitedBy")) } : {},
+    ...has(input, modeKey) ? { [modeKey]: literal(r.field(modeKey), r.at(modeKey), LISTENING_MODES) } : {}
+  };
+}
+function decodeLocalNameContent(input) {
+  return decodeWith(() => readNameContent(input, ""));
+}
+function decodeLocalMemberContent(input) {
+  return decodeWith(() => readMemberContent(input, ""));
+}
+var EVENT_TYPES = ["m.room.create", "m.room.name", "m.room.member", "m.room.message", "com.khala.event.v1", "com.khala.listening_mode.v1"];
+function readContent(input, path2, type) {
+  switch (type) {
+    case "m.room.create":
+      return readCreateContent(input, path2);
+    case "m.room.name":
+      return readNameContent(input, path2);
+    case "m.room.member":
+      return readMemberContent(input, path2);
+    default: {
+      const content = contentObject(input, path2);
+      if (type === "m.room.message") {
+        literal(content["msgtype"], `${path2}.msgtype`, ["m.text", "m.notice"]);
+        const body = text(content["body"], `${path2}.body`, LOCAL_CONTENT_MAX_BYTES);
+        if (body.length === 0) fail(`${path2}.body`, "empty");
+        if (body.length > LOCAL_BODY_MAX_CHARS) fail(`${path2}.body`, "too_long");
+      }
+      return content;
+    }
+  }
+}
+function readEvent(input, path2) {
+  const r = record(input, path2, ["seq", "eventId", "roomId", "type", "sender", "ts", "content"], ["txnId"]);
+  const type = literal(r.field("type"), r.at("type"), EVENT_TYPES);
+  return {
+    seq: seq(r.field("seq"), r.at("seq")),
+    eventId: readLocalEventId(r.field("eventId"), r.at("eventId")),
+    roomId: readLocalRoomId(r.field("roomId"), r.at("roomId")),
+    type,
+    sender: readLocalUserId(r.field("sender"), r.at("sender")),
+    ts: safeInteger(r.field("ts"), r.at("ts")),
+    ...has(input, "txnId") ? { txnId: readLocalTxnId(r.field("txnId"), r.at("txnId")) } : {},
+    content: readContent(r.field("content"), r.at("content"), type)
+  };
+}
+function decodeLocalEvent(input) {
+  return decodeWith(() => readEvent(input, ""));
+}
+function limitedArray(input, path2, max, read) {
+  const values = array(input, path2);
+  if (values.length > max) fail(path2, "too_long");
+  return values.map((value, i) => read(value, elementPath(path2, i)));
+}
+function readEvents(input, path2, history) {
+  const events = limitedArray(input, path2, history ? LOCAL_HISTORY_LIMIT_MAX : LOCAL_EVENTS_PAGE_MAX, readEvent);
+  events.forEach((event, i) => {
+    if (i > 0 && event.seq <= events[i - 1].seq) fail(`${elementPath(path2, i)}.seq`, "invalid_value");
+    if (history && event.type !== "m.room.message" && event.type !== "com.khala.event.v1") fail(`${elementPath(path2, i)}.type`, "invalid_value");
+  });
+  return events;
+}
+function decodeLocalEventsPage(input) {
+  return decodeWith(() => {
+    const r = object(input, "", ["events", "next"]);
+    const events = readEvents(r.field("events"), r.at("events"), false);
+    const next = safeInteger(r.field("next"), r.at("next"));
+    if (events.length > 0 && next !== events.at(-1).seq) fail(r.at("next"), "invalid_value");
+    return { events, next };
+  });
+}
+function decodeLocalHistoryPage(input) {
+  return decodeWith(() => {
+    const r = record(input, "", ["events"], ["nextBefore"]);
+    return {
+      events: readEvents(r.field("events"), r.at("events"), true),
+      ...has(input, "nextBefore") ? { nextBefore: readLocalEventId(r.field("nextBefore"), r.at("nextBefore")) } : {}
+    };
+  });
+}
+function readLocalMe(input, path2) {
+  const r = record(input, path2, ["userId", "roomId", "roomName", "membership", "displayName"], ["invitedBy"]);
+  return {
+    userId: readLocalUserId(r.field("userId"), r.at("userId")),
+    roomId: readLocalRoomId(r.field("roomId"), r.at("roomId")),
+    roomName: channelName(r.field("roomName"), r.at("roomName")),
+    membership: literal(r.field("membership"), r.at("membership"), ["invite", "join", "leave"]),
+    ...has(input, "invitedBy") ? { invitedBy: readLocalUserId(r.field("invitedBy"), r.at("invitedBy")) } : {},
+    displayName: displayName(r.field("displayName"), r.at("displayName"))
+  };
+}
+function decodeLocalMe(input) {
+  return decodeWith(() => readLocalMe(input, ""));
+}
+function readLocalJoined(input, path2) {
+  const r = record(input, path2, ["seq", "ts"], []);
+  return {
+    seq: seq(r.field("seq"), r.at("seq")),
+    ts: safeInteger(r.field("ts"), r.at("ts"))
+  };
+}
+function decodeLocalJoined(input) {
+  return decodeWith(() => readLocalJoined(input, ""));
+}
+function readLocalSendResult(input, path2) {
+  const r = record(input, path2, ["eventId"], []);
+  return {
+    eventId: readLocalEventId(r.field("eventId"), r.at("eventId"))
+  };
+}
+function decodeLocalSendResult(input) {
+  return decodeWith(() => readLocalSendResult(input, ""));
+}
+function readLocalErrorBody(input, path2) {
+  const r = record(input, path2, ["error"], []);
+  return {
+    error: identifier(r.field("error"), r.at("error"))
+  };
+}
+function decodeLocalErrorBody(input) {
+  return decodeWith(() => readLocalErrorBody(input, ""));
+}
+function readOwnerProfile(input, path2) {
+  const r = record(input, path2, ["v", "username", "color", "initials", "updatedAt"]);
+  return {
+    v: version(r.field("v"), r.at("v")),
+    username: readLocalUsername(r.field("username"), r.at("username")),
+    color: readHumanColorId(r.field("color"), r.at("color")),
+    initials: nullableInitials(r.field("initials"), r.at("initials")),
+    updatedAt: utcTimestamp(r.field("updatedAt"), r.at("updatedAt"))
+  };
+}
+function decodeOwnerProfile(input) {
+  return decodeWith(() => readOwnerProfile(input, ""));
+}
+function nullableInitials(input, path2) {
+  return nullable(input, (value) => readLocalInitials(value, path2));
+}
+function readMember(input, path2) {
+  const r = record(input, path2, ["userId", "participantId", "ownerId", "deviceId", "displayName", "kind", "membership"], ["harness", "ownerLabel", "listeningMode"]);
+  const userId = readLocalUserId(r.field("userId"), r.at("userId"));
+  const participantId = readLocalUserId(r.field("participantId"), r.at("participantId"));
+  if (participantId !== userId) fail(r.at("participantId"), "invalid_value");
+  const deviceId = identifier(r.field("deviceId"), r.at("deviceId"));
+  if (userId === LOCAL_OWNER_USER_ID ? deviceId !== LOCAL_OWNER_DEVICE_ID : !/^KH_LOCAL_[0-9a-f]{8}$/u.test(deviceId)) fail(r.at("deviceId"), "invalid_value");
+  const kind = literal(r.field("kind"), r.at("kind"), ["human", "agent"]);
+  if (kind === "human") {
+    for (const key of ["harness", "ownerLabel", "listeningMode"]) if (has(input, key)) fail(r.at(key), "invalid_value");
+  }
+  return {
+    userId,
+    participantId,
+    ownerId: literal(r.field("ownerId"), r.at("ownerId"), [LOCAL_OWNER_ID]),
+    deviceId,
+    displayName: displayName(r.field("displayName"), r.at("displayName")),
+    kind,
+    membership: literal(r.field("membership"), r.at("membership"), ["invite", "join"]),
+    ...has(input, "harness") ? { harness: readHarness(r.field("harness"), r.at("harness")) } : {},
+    ...has(input, "ownerLabel") ? { ownerLabel: readLocalUsername(r.field("ownerLabel"), r.at("ownerLabel")) } : {},
+    ...has(input, "listeningMode") ? { listeningMode: literal(r.field("listeningMode"), r.at("listeningMode"), LISTENING_MODES) } : {}
+  };
+}
+function decodeLocalMembersResponse(input) {
+  return decodeWith(() => {
+    const r = object(input, "", ["members"]);
+    const members = limitedArray(r.field("members"), r.at("members"), LOCAL_MEMBERS_MAX, readMember);
+    const seen = /* @__PURE__ */ new Set();
+    members.forEach((member, i) => {
+      if (seen.has(member.userId)) fail(`${elementPath(r.at("members"), i)}.userId`, "duplicate");
+      seen.add(member.userId);
+    });
+    return { members };
+  });
+}
+function decodeHelperFile(input) {
+  return decodeWith(() => {
+    const r = object(input, "", ["v", "pid", "port", "origin", "adminToken", "version", "startedAt"]);
+    const pid = seq(r.field("pid"), r.at("pid"));
+    const port = seq(r.field("port"), r.at("port"));
+    if (port > 65535) fail(r.at("port"), "invalid_value");
+    const origin = readHttpUrl(r.field("origin"), r.at("origin"));
+    if (origin !== `http://127.0.0.1:${port}`) fail(r.at("origin"), "invalid_value");
+    const adminToken = identifier(r.field("adminToken"), r.at("adminToken"));
+    if (!/^[A-Za-z0-9_-]{43}$/u.test(adminToken)) fail(r.at("adminToken"), "invalid_value");
+    return {
+      v: version(r.field("v"), r.at("v")),
+      pid,
+      port,
+      origin,
+      adminToken,
+      version: identifier(r.field("version"), r.at("version")),
+      startedAt: utcTimestamp(r.field("startedAt"), r.at("startedAt"))
+    };
+  });
+}
+function readSha256(input, path2) {
+  const value = identifier(input, path2);
+  if (!/^[0-9a-f]{64}$/u.test(value)) fail(path2, "invalid_value");
+  return value;
+}
+function decodeChannelSecrets(input) {
+  return decodeWith(() => {
+    const r = object(input, "", ["v", "links", "members"]);
+    const links = Object.fromEntries(Object.entries(plainObject(r.field("links"), r.at("links"))).map(([key, value]) => {
+      const path2 = `${r.at("links")}.${key}`;
+      readSha256(key, path2);
+      const link = record(value, path2, ["expiresAt", "kind"], ["consumedAt"]);
+      return [key, {
+        expiresAt: utcTimestamp(link.field("expiresAt"), link.at("expiresAt")),
+        kind: literal(link.field("kind"), link.at("kind"), ["join"]),
+        ...has(value, "consumedAt") ? { consumedAt: utcTimestamp(link.field("consumedAt"), link.at("consumedAt")) } : {}
+      }];
+    }));
+    const members = Object.fromEntries(Object.entries(plainObject(r.field("members"), r.at("members"))).map(([key, value]) => {
+      const path2 = `${r.at("members")}.${key}`;
+      if (!isLocalAgentUserId(key)) fail(path2, "invalid_value");
+      const member = object(value, path2, ["tokenSha256"]);
+      return [key, { tokenSha256: readSha256(member.field("tokenSha256"), member.at("tokenSha256")) }];
+    }));
+    return { v: version(r.field("v"), r.at("v")), links, members };
+  });
+}
+
+// src/local/lifecycle.ts
+import * as fs from "node:fs/promises";
+import { close as closeFd } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { setTimeout as sleepDefault } from "node:timers/promises";
+import { spawn as nodeSpawn } from "node:child_process";
+function helperPaths(env = process.env) {
+  const root = path.join(stateRoot(env), "local");
+  const candidate = /^\d{1,5}$/u.test(env.KHALA_LOCAL_PORT ?? "") ? Number(env.KHALA_LOCAL_PORT) : 0;
+  const port = candidate >= 1 && candidate <= 65535 ? candidate : LOCAL_DEFAULT_PORT;
+  return { root, helperFile: path.join(root, "helper.json"), logFile: path.join(root, "helper.log"), port, origin: `http://127.0.0.1:${port}` };
+}
+async function readHelperFile(env = process.env) {
+  const decoded = decodeHelperFile(await readJson(helperPaths(env).helperFile));
+  if (!decoded.ok) return null;
+  const file = decoded.value;
+  if (!Number.isSafeInteger(file.pid) || file.pid <= 0 || !Number.isSafeInteger(file.port) || file.port <= 0 || file.port > 65535 || file.origin !== `http://127.0.0.1:${file.port}` || !/^[A-Za-z0-9_-]{43}$/u.test(file.adminToken)) return null;
+  return file;
+}
+function helperBinPath() {
+  return fileURLToPath(bundle ? new URL("./khala.mjs", import.meta.url) : new URL("../../bin/khala.mjs", import.meta.url));
+}
+var HELPER_ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "LANG",
+  "LC_ALL",
+  "TMPDIR",
+  "XDG_STATE_HOME",
+  "NODE_OPTIONS",
+  "KHALA_EGRESS_LOG",
+  "KHALA_LOCAL_PORT",
+  "KHALA_LOCAL_IDLE_MS",
+  "KHALA_LOCAL_WEB_DIR"
+];
+function helperChildEnv(env) {
+  const childEnv = {};
+  for (const key of HELPER_ENV_ALLOWLIST) if (env[key] !== void 0) childEnv[key] = env[key];
+  return childEnv;
+}
+var attempts = /* @__PURE__ */ new Map();
+async function healthy(fetchImpl, file) {
+  try {
+    const response = await fetchImpl(`${file.origin}/healthz`, { signal: AbortSignal.timeout(500) });
+    if (response.status !== 200) {
+      await response.body?.cancel();
+      return false;
+    }
+    const body = await response.json();
+    return typeof body === "object" && body !== null && "ok" in body && body.ok === true && "pid" in body && body.pid === file.pid;
+  } catch {
+    return false;
+  }
+}
+function connection(file) {
+  return { origin: file.origin, adminToken: file.adminToken };
+}
+async function attempt(env, deps) {
+  const fetchImpl = deps.fetch ?? globalThis.fetch;
+  const spawn = deps.spawn ?? ((command, argv, options) => nodeSpawn(command, [...argv], options));
+  const sleep = deps.sleep ?? sleepDefault;
+  const now = deps.now ?? Date.now;
+  const existing = await readHelperFile(env);
+  if (existing && await healthy(fetchImpl, existing)) return connection(existing);
+  const paths = helperPaths(env);
+  try {
+    await ensureStateDir(path.join(paths.root, "channels"));
+    let handle;
+    let fd;
+    let spawnFailed = false;
+    try {
+      if (deps.openLog) fd = await deps.openLog(paths.logFile);
+      else {
+        handle = await fs.open(paths.logFile, "a", 384);
+        await handle.chmod(384);
+        fd = handle.fd;
+      }
+      const child = spawn(process.execPath, [helperBinPath(), "local", "serve"], {
+        detached: true,
+        stdio: ["ignore", fd, fd],
+        env: helperChildEnv(env),
+        cwd: paths.root,
+        shell: false
+      });
+      child.on("error", () => {
+        spawnFailed = true;
+      });
+      child.unref();
+    } finally {
+      if (handle) await handle.close();
+      else if (fd !== void 0) {
+        const descriptor = fd;
+        await new Promise((resolve) => {
+          closeFd(descriptor, () => resolve());
+        });
+      }
+    }
+    const deadline = now() + 5e3;
+    while (!spawnFailed && now() < deadline) {
+      const file = await readHelperFile(env);
+      if (file && await healthy(fetchImpl, file) && !spawnFailed && now() <= deadline) return connection(file);
+      if (spawnFailed || now() >= deadline) break;
+      await sleep(100);
+    }
+  } catch (error) {
+    if (error instanceof StateError) throw error;
+  }
+  throw new KhalaClientError("internal_error", "helper_unavailable");
+}
+function ensureHelper(env = process.env, deps = {}) {
+  const key = helperPaths(env).helperFile;
+  const pending = attempts.get(key);
+  if (pending) return pending;
+  const promise = attempt(env, deps).finally(() => {
+    attempts.delete(key);
+  });
+  attempts.set(key, promise);
+  return promise;
+}
+
+export {
+  LOCAL_OWNER_USER_ID,
+  LOCAL_LINK_TTL_MS,
+  LOCAL_LONG_POLL_MAX_S,
+  LOCAL_IDLE_EXIT_MS,
+  LOCAL_TOKEN_BYTES,
+  LOCAL_AGENT_DEVICE_PREFIX,
+  base64url,
+  newLocalRoomId,
+  newLocalAgentUserId,
+  newLocalEventId,
+  isLocalRoomId,
+  localRoomKey,
+  localRoomPath,
+  LOCAL_OWNER_ID,
+  LOCAL_OWNER_DEVICE_ID,
+  decodeLocalNameContent,
+  decodeLocalMemberContent,
+  decodeLocalEvent,
+  decodeLocalEventsPage,
+  decodeLocalHistoryPage,
+  decodeLocalMe,
+  decodeLocalJoined,
+  decodeLocalSendResult,
+  decodeLocalErrorBody,
+  decodeOwnerProfile,
+  decodeLocalMembersResponse,
+  decodeChannelSecrets,
+  helperPaths,
+  readHelperFile,
+  ensureHelper
+};

package/dist/khala.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  KHALA_AGENT_VERSION
+} from "./chunk-Y3TDVOGT.mjs";
+import "./chunk-HMGN52QY.mjs";
+import "./chunk-6FNXMYOM.mjs";
+
+// src/cli.ts
+var HOOK_NAME = /^[a-z][a-z0-9-]{0,31}$/;
+var STDIN_CAP = 1024 * 1024;
+var USAGE = "usage: khala mcp | khala hook <name> | khala local <command> | khala install codex | khala --version";
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of process.stdin) {
+    size += chunk.length;
+    if (size > STDIN_CAP) return "";
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+function exitCode(value) {
+  if (typeof value !== "number" || !Number.isInteger(value)) throw new Error("bad_exit");
+  return value;
+}
+async function runCli(argv, modules) {
+  const [cmd, ...rest] = argv;
+  if (cmd === "--version") {
+    console.log(KHALA_AGENT_VERSION);
+    return 0;
+  }
+  if (cmd === "mcp" || cmd === "install") {
+    const load = modules[cmd]();
+    if (!load) {
+      console.error(`khala: ${cmd} not available`);
+      return 1;
+    }
+    try {
+      return exitCode(await (await load()).default(rest));
+    } catch {
+      console.error("khala: internal_error");
+      return 1;
+    }
+  }
+  if (cmd === "local") {
+    const load = modules.local();
+    if (!load) {
+      console.log('{"error":"internal_error"}');
+      return 1;
+    }
+    try {
+      return exitCode(await (await load()).default(rest));
+    } catch {
+      console.log('{"error":"internal_error"}');
+      return 1;
+    }
+  }
+  if (cmd === "hook") {
+    const [name = "", ...args] = rest;
+    const load = HOOK_NAME.test(name) ? modules.hook(name) : void 0;
+    if (!load) {
+      console.error(`khala: unknown hook ${name}`);
+      return 1;
+    }
+    try {
+      const run = (await load()).default;
+      return exitCode(await run(await readStdin(), args));
+    } catch {
+      process.stderr.write('{"ok":false,"warning":"khala_hook_suppressed","code":"internal_error"}\n');
+      return 1;
+    }
+  }
+  console.error(USAGE);
+  return 1;
+}
+
+// src/cli-bundle.ts
+var hooks = {
+  deliver: () => import("./chunk-PQO6675G.mjs"),
+  "claude-wake": () => import("./chunk-525XNG6V.mjs")
+};
+process.exitCode = await runCli(process.argv.slice(2), {
+  mcp: () => () => import("./chunk-MGXWUWWP.mjs"),
+  local: () => () => import("./chunk-HWKLLI7F.mjs"),
+  install: () => () => import("./chunk-FGIU3YO2.mjs"),
+  hook: (name) => Object.hasOwn(hooks, name) ? hooks[name] : void 0
+});