khala-cli 0.4.4 → 0.4.6

package/dist/chunk-WHONG7UF.mjs

@@ -0,0 +1,267 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  CURSOR_DEFAULT_SESSION,
+  CURSOR_WORKSPACE_ENV,
+  cursorSessionId,
+  readActivity,
+  readListeningMode
+} from "./chunk-ZHMGB3PP.mjs";
+import {
+  listChannels,
+  readCursor,
+  unreadCount
+} from "./chunk-XUJIJ4KB.mjs";
+import {
+  HARNESS_REGISTRY
+} from "./chunk-DPW43YNC.mjs";
+import {
+  SESSION_ID_PATTERN,
+  readJson
+} from "./chunk-OW3DSTEZ.mjs";
+
+// src/harness/claude.ts
+var claude = {
+  id: "claude",
+  sessionSources: [(_meta, env) => env.CLAUDE_CODE_SESSION_ID],
+  codec: void 0,
+  rejoinable: () => true,
+  watcherStatus: true
+};
+
+// src/wake/codex.ts
+import path from "node:path";
+
+// src/wake/idle-wake.ts
+var CODEX_IDLE_WAKE_NOTICE = "Khala: channel messages are waiting. Continue.";
+function codexIdleWakeArgv(sessionId) {
+  return ["queue", "--thread", sessionId, "--message", CODEX_IDLE_WAKE_NOTICE];
+}
+
+// src/wake/idle-wake-process.ts
+import { spawn as nodeSpawn } from "node:child_process";
+var CODEX_QUEUE_ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "TMPDIR",
+  "CODEX_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_STATE_HOME",
+  "XDG_RUNTIME_DIR"
+];
+function scrubbedQueueEnv(source) {
+  const env = {};
+  for (const name of CODEX_QUEUE_ENV_ALLOWLIST) {
+    const value = source[name];
+    if (value !== void 0) env[name] = value;
+  }
+  return env;
+}
+function createCodexQueueProcessPort(deps) {
+  const spawn = deps.spawn ?? ((command, argv, options) => nodeSpawn(command, [...argv], options));
+  const timeoutMs = deps.timeoutMs ?? 1e4;
+  return {
+    run(argv, signal) {
+      return new Promise((resolve) => {
+        if (signal.aborted) return resolve({ status: "not_started" });
+        let child;
+        try {
+          child = spawn(deps.command, argv, { shell: false, stdio: "ignore", env: scrubbedQueueEnv(deps.env) });
+        } catch {
+          return resolve({ status: "not_started" });
+        }
+        let timedOut = false;
+        let stopped = false;
+        let force = null;
+        const stop = () => {
+          if (stopped) return;
+          stopped = true;
+          child.kill("SIGTERM");
+          force = setTimeout(() => {
+            child.kill("SIGKILL");
+          }, 500);
+        };
+        const timer = setTimeout(() => {
+          timedOut = true;
+          stop();
+        }, timeoutMs);
+        signal.addEventListener("abort", stop, { once: true });
+        const settle = (outcome) => {
+          clearTimeout(timer);
+          if (force !== null) clearTimeout(force);
+          signal.removeEventListener("abort", stop);
+          resolve(outcome);
+        };
+        child.on("error", () => settle({ status: "not_started" }));
+        child.on("close", (code) => settle(timedOut ? { status: "lost", cause: "timeout" } : code === 0 ? { status: "queued" } : { status: "exited", code: code ?? -1 }));
+      });
+    }
+  };
+}
+
+// src/wake/codex.ts
+function createCodexWaker(deps) {
+  if (!SESSION_ID_PATTERN.test(deps.threadId)) throw new TypeError("invalid_thread_id");
+  const port = deps.port ?? createCodexQueueProcessPort({ command: "codex", env: process.env });
+  const now = deps.now ?? Date.now;
+  const stderr = deps.stderr ?? ((line) => {
+    process.stderr.write(line);
+  });
+  const controller = new AbortController();
+  let pending;
+  const wakesAtCount = /* @__PURE__ */ new Map();
+  const identities = /* @__PURE__ */ new Map();
+  let stopped = false;
+  let again = false;
+  let inFlight;
+  const warn = (warning, status) => {
+    try {
+      stderr(JSON.stringify({ ok: false, warning, ...status ? { status } : {} }) + "\n");
+    } catch {
+    }
+  };
+  const evaluate = async () => {
+    try {
+      const channels = await listChannels(deps.files);
+      const eligible = [];
+      const currentIdentities = /* @__PURE__ */ new Map();
+      for (const channel of channels) {
+        const session = await readJson(channel.files.session);
+        const metadata = channel.legacy ? null : await readJson(path.join(channel.files.dir, "channel.json"));
+        currentIdentities.set(channel.key, JSON.stringify([session?.roomId ?? channel.roomId, session?.userId, metadata?.joinedAt]));
+        if (await readListeningMode(channel.files) === "async") continue;
+        eligible.push({
+          channel,
+          counts: await unreadCount(channel.files.dir),
+          cursor: await readCursor(channel.files)
+        });
+      }
+      const keys = new Set(currentIdentities.keys());
+      const changed = /* @__PURE__ */ new Set();
+      for (const [key, identity] of currentIdentities) {
+        if (identities.get(key) !== identity) changed.add(key);
+      }
+      for (const key of identities.keys()) if (!keys.has(key)) changed.add(key);
+      if (changed.size) {
+        for (const [key, wakes2] of [...wakesAtCount]) {
+          const pairs2 = JSON.parse(key);
+          if (!pairs2.some(([id]) => changed.has(id))) continue;
+          wakesAtCount.delete(key);
+          const remainingPairs = pairs2.filter(([id]) => !changed.has(id));
+          if (!remainingPairs.length) continue;
+          const remaining = JSON.stringify(remainingPairs);
+          wakesAtCount.set(remaining, Math.max(wakes2, wakesAtCount.get(remaining) ?? 0));
+        }
+      }
+      for (const key of changed) identities.delete(key);
+      for (const [key, identity] of currentIdentities) identities.set(key, identity);
+      const pairs = eligible.map(({ channel, cursor: cursor2 }) => [channel.key, cursor2.deliveredCount]).sort(([a], [b]) => a.localeCompare(b));
+      const budgetKey = JSON.stringify(pairs);
+      if (changed.size) {
+        const inheritedKey = JSON.stringify(pairs.filter(([key]) => !changed.has(key)));
+        const newUnread = eligible.some((item) => changed.has(item.channel.key) && item.counts.messages > 0);
+        wakesAtCount.set(budgetKey, newUnread ? 0 : wakesAtCount.get(inheritedKey) ?? 0);
+        if (newUnread || !eligible.some((item) => !changed.has(item.channel.key) && item.counts.messages > 0)) pending = void 0;
+      }
+      if (!eligible.some((item) => item.counts.messages > 0)) {
+        pending = void 0;
+        return;
+      }
+      const activity = await readActivity(deps.files);
+      if (pending && Date.parse(activity.updatedAt) > pending.at) pending = void 0;
+      const at = now();
+      if (pending && at - pending.at < (deps.retryAfterMs ?? 6e4)) return;
+      if (stopped || activity.state !== "idle") return;
+      const wakes = wakesAtCount.get(budgetKey) ?? 0;
+      if (wakes >= 2) return;
+      for (const { channel } of eligible) {
+        if (await readListeningMode(channel.files) === "async") {
+          pending = void 0;
+          return;
+        }
+      }
+      if (stopped) return;
+      pending = { at };
+      wakesAtCount.set(budgetKey, wakes + 1);
+      const outcome = await port.run(codexIdleWakeArgv(deps.threadId), controller.signal);
+      if (outcome.status !== "queued") warn("codex_queue_failed", outcome.status);
+    } catch {
+      warn("codex_waker_error");
+    }
+  };
+  const notify = () => {
+    if (stopped) return;
+    if (inFlight) {
+      again = true;
+      return;
+    }
+    inFlight = (async () => {
+      do {
+        again = false;
+        await evaluate();
+      } while (again && !stopped);
+    })().finally(() => {
+      inFlight = void 0;
+      if (again && !stopped) notify();
+    });
+  };
+  const timer = setInterval(notify, deps.pollMs ?? 1e3);
+  timer.unref();
+  return {
+    notify,
+    async stop() {
+      stopped = true;
+      again = false;
+      clearInterval(timer);
+      controller.abort();
+      await inFlight;
+    }
+  };
+}
+
+// src/harness/codex.ts
+var install = async (flags, deps) => (await import("./chunk-6E3UCO22.mjs")).runCodexInstall(flags, deps);
+var codex = {
+  id: "codex",
+  // A string metadata id wins even when empty or invalid; validation happens after selection.
+  sessionSources: [(meta, env) => typeof meta?.threadId === "string" ? meta.threadId : env.CODEX_THREAD_ID],
+  codec: void 0,
+  install,
+  uninstall: (flags, deps) => install([...flags, "--uninstall"], deps),
+  waker: createCodexWaker,
+  rejoinable: () => true
+};
+
+// src/harness/cursor.ts
+var install2 = async (flags, deps) => (await import("./chunk-6E3UCO22.mjs")).runCursorInstall(flags, deps);
+var cursor = {
+  id: "cursor",
+  sessionSources: [(_meta, env) => cursorSessionId(env[CURSOR_WORKSPACE_ENV])],
+  codec: void 0,
+  install: install2,
+  uninstall: (flags, deps) => install2([...flags, "--uninstall"], deps),
+  rejoinable: (source) => source !== CURSOR_DEFAULT_SESSION
+};
+
+// src/harness/index.ts
+function createAdapterRegistry(adapters) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const adapter of adapters) {
+    if (byId.has(adapter.id)) throw new Error(`duplicate_adapter: ${adapter.id}`);
+    if (!HARNESS_REGISTRY.some((row) => row.id === adapter.id)) throw new Error(`unregistered_adapter: ${adapter.id}`);
+    byId.set(adapter.id, adapter);
+  }
+  return Object.freeze({ resolve: (id) => byId.get(id) });
+}
+var ADAPTERS = Object.freeze([claude, codex, cursor]);
+var registry = createAdapterRegistry(ADAPTERS);
+var adapterFor = registry.resolve;
+
+export {
+  adapterFor
+};

package/dist/chunk-XUJIJ4KB.mjs

@@ -0,0 +1,216 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  StateError,
+  channelFiles,
+  channelsDir,
+  ensureStateDir,
+  filesForDir,
+  readJson,
+  readStatus,
+  removeStateFile,
+  stateKey,
+  writeJsonAtomic,
+  writeStateFile
+} from "./chunk-OW3DSTEZ.mjs";
+
+// src/inbox.ts
+import * as fs from "node:fs/promises";
+async function readEntries(files) {
+  let content;
+  try {
+    content = await fs.readFile(files.inbox, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw new StateError("storage_failed");
+  }
+  const entries = [];
+  for (const line of content.split("\n").slice(0, -1)) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry && ["eventId", "roomId", "ts", "sender", "senderLabel", "body"].every((key) => typeof entry[key] === "string") && ["human", "agent", "unknown"].includes(entry.senderKind) && ["message", "event"].includes(entry.kind)) entries.push(entry);
+    } catch {
+    }
+  }
+  return entries;
+}
+async function appendEntries(files, entries) {
+  const seen = new Set((await readEntries(files)).map((entry) => entry.eventId));
+  const fresh = entries.filter((entry) => {
+    if (seen.has(entry.eventId)) return false;
+    seen.add(entry.eventId);
+    return true;
+  });
+  if (fresh.length) {
+    try {
+      await fs.appendFile(files.inbox, fresh.map((entry) => JSON.stringify(entry) + "\n").join(""), { mode: 384, flag: "a" });
+    } catch {
+      throw new StateError("storage_failed");
+    }
+  }
+  return fresh;
+}
+async function readCursor(files) {
+  const cursor = await readJson(files.cursor);
+  return cursor && (cursor.lastDeliveredEventId === null || typeof cursor.lastDeliveredEventId === "string") && Number.isSafeInteger(cursor.deliveredCount) && cursor.deliveredCount >= 0 ? cursor : { lastDeliveredEventId: null, deliveredCount: 0 };
+}
+async function unread(files) {
+  const cursor = await readCursor(files);
+  const entries = await readEntries(files);
+  return { entries: entries.slice(cursor.deliveredCount), cursor };
+}
+async function unreadCounts(files) {
+  const { entries } = await unread(files);
+  return { total: entries.length, messages: entries.filter((entry) => entry.kind === "message").length };
+}
+async function advanceCursor(files, expected, delivered) {
+  const current = await readCursor(files);
+  if (current.deliveredCount !== expected.deliveredCount || current.lastDeliveredEventId !== expected.lastDeliveredEventId) return "conflict";
+  if (!delivered.length) return expected;
+  const entries = await readEntries(files);
+  const slice = entries.slice(expected.deliveredCount, expected.deliveredCount + delivered.length);
+  if (slice.length !== delivered.length || slice.some((entry, index) => entry.eventId !== delivered[index]?.eventId)) return "conflict";
+  const next = { lastDeliveredEventId: delivered[delivered.length - 1].eventId, deliveredCount: expected.deliveredCount + delivered.length };
+  await writeJsonAtomic(files.cursor, next);
+  return next;
+}
+async function appendInbox(dir, entry) {
+  return (await appendEntries(filesForDir(dir), [entry])).length === 1;
+}
+function unreadCount(dir) {
+  return unreadCounts(filesForDir(dir));
+}
+
+// src/channels.ts
+import * as fs2 from "node:fs/promises";
+import path from "node:path";
+function channelKey(roomId2) {
+  return stateKey(roomId2);
+}
+async function exists(file) {
+  try {
+    await fs2.lstat(file);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw new StateError("storage_failed");
+  }
+}
+function roomId(value) {
+  if (value && typeof value === "object" && "roomId" in value && typeof value.roomId === "string" && value.roomId.length) return value.roomId;
+  return void 0;
+}
+async function legacyRoomId(files) {
+  const saved = roomId(await readJson(files.session));
+  if (saved) return saved;
+  let content;
+  try {
+    content = await fs2.readFile(files.inbox, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw new StateError("storage_failed");
+  }
+  try {
+    return roomId(JSON.parse(content.split("\n")[0]));
+  } catch {
+    return void 0;
+  }
+}
+async function listChannels(files) {
+  await ensureStateDir(files.dir);
+  const channels = [];
+  const dir = channelsDir(files);
+  if (await exists(dir)) {
+    await ensureStateDir(dir);
+    for (const key of await fs2.readdir(dir)) {
+      if (!/^[a-f0-9]{24}$/.test(key)) continue;
+      const nested = filesForDir(path.join(dir, key));
+      await ensureStateDir(nested.dir);
+      const metadata = await readJson(path.join(nested.dir, "channel.json"));
+      const id = roomId(metadata);
+      if (!id || channelKey(id) !== key) continue;
+      channels.push({ key, roomId: id, ...typeof metadata?.channelName === "string" ? { channelName: metadata.channelName } : {}, files: nested, legacy: false });
+    }
+  }
+  if (await exists(files.inbox)) {
+    const id = await legacyRoomId(files);
+    if (id) {
+      const status = await readStatus(files);
+      channels.push({ key: channelKey(id), roomId: id, ...typeof status?.channelName === "string" ? { channelName: status.channelName } : {}, files, legacy: true });
+    }
+  }
+  return channels.sort((a, b) => (a.channelName ?? "").localeCompare(b.channelName ?? "") || a.roomId.localeCompare(b.roomId));
+}
+async function migrateLegacy(files) {
+  await ensureStateDir(files.dir);
+  const names = ["cursor.json", "mode.json", "inbox.jsonl"];
+  const present = await Promise.all(names.map((name) => exists(path.join(files.dir, name))));
+  if (!present.some(Boolean)) return "none";
+  const id = await legacyRoomId(files);
+  if (!id) {
+    for (const name of names) await removeStateFile(files.dir, name);
+    return "discarded";
+  }
+  const nested = channelFiles(files, id);
+  await ensureStateDir(nested.dir);
+  const destinationInbox = await exists(nested.inbox);
+  if (!destinationInbox && present[0] && await exists(nested.cursor)) {
+    const [legacyCursor, channelCursor] = await Promise.all([readCursor(files), readCursor(nested)]);
+    if (legacyCursor.deliveredCount !== channelCursor.deliveredCount || legacyCursor.lastDeliveredEventId !== channelCursor.lastDeliveredEventId) {
+      const safe = legacyCursor.deliveredCount < channelCursor.deliveredCount ? legacyCursor : channelCursor;
+      await writeStateFile(nested.dir, "cursor.json", safe);
+      console.warn(`Khala cursor migration: conflicting cursors for ${id}; using earlier position ${safe.deliveredCount} to avoid skipping messages (legacy=${legacyCursor.deliveredCount}, channel=${channelCursor.deliveredCount}).`);
+    }
+  }
+  const status = await readStatus(files);
+  const metadata = await readJson(path.join(nested.dir, "channel.json"));
+  if (!metadata || roomId(metadata) !== id) {
+    await writeStateFile(nested.dir, "channel.json", {
+      roomId: id,
+      ...typeof status?.channelName === "string" ? { channelName: status.channelName } : {},
+      joinedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  if (destinationInbox) {
+    if (present[2]) await appendEntries(nested, (await unread(files)).entries);
+    for (const name of ["inbox.jsonl", "cursor.json", "mode.json"]) await removeStateFile(files.dir, name);
+    return "moved";
+  }
+  for (const name of names) {
+    if (await exists(path.join(nested.dir, name))) {
+      await removeStateFile(files.dir, name);
+      continue;
+    }
+    try {
+      await fs2.rename(path.join(files.dir, name), path.join(nested.dir, name));
+    } catch (error) {
+      if (error.code !== "ENOENT") throw new StateError("storage_failed");
+    }
+  }
+  return "moved";
+}
+function resolveChannel(list, ref) {
+  const channels = list.map((item) => ({ channel: item.channelName ?? item.roomId, roomId: item.roomId }));
+  if (ref === void 0) {
+    if (list.length === 1) return { ok: true, channel: list[0] };
+    return { ok: false, code: list.length ? "channel_required" : "channel_unknown", channels };
+  }
+  const exact = list.find((item) => item.roomId === ref);
+  if (exact) return { ok: true, channel: exact };
+  const normalized = ref.replace(/^#/, "").toLowerCase();
+  const matches = list.filter((item) => item.channelName?.replace(/^#/, "").toLowerCase() === normalized);
+  if (matches.length === 1) return { ok: true, channel: matches[0] };
+  return { ok: false, code: matches.length ? "channel_ambiguous" : "channel_unknown", channels };
+}
+
+export {
+  readEntries,
+  readCursor,
+  unread,
+  advanceCursor,
+  appendInbox,
+  unreadCount,
+  channelKey,
+  listChannels,
+  migrateLegacy,
+  resolveChannel
+};