khala-cli 0.4.2 → 0.4.5

package/dist/{chunk-T6RZE5IQ.mjs → chunk-6LC66VHK.mjs}

@@ -1,7 +1,7 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
   ensureHelper
-} from "./chunk-YP45XTOH.mjs";
+} from "./chunk-HB3UGIZG.mjs";
 import {
   KhalaClientError,
   LOCAL_LONG_POLL_MAX_S,
@@ -16,16 +16,19 @@ import {
   decodeLocalNameContent,
   decodeLocalSendResult,
   localRoomPath
-} from "./chunk-BZ53MZEE.mjs";
-import "./chunk-B5BFL7OD.mjs";
+} from "./chunk-TZKEQIHP.mjs";
+import "./chunk-OLZ62X7S.mjs";
 import "./chunk-5GLTKWJ5.mjs";
 import {
   CHANNEL_EVENT_TYPE,
-  LISTENING_MODE_COMMAND_TYPE,
   memberRenameContent
-} from "./chunk-N6LMHR7P.mjs";
-import "./chunk-RW3DXWNC.mjs";
-import "./chunk-A3LJU4JA.mjs";
+} from "./chunk-P5CP32X2.mjs";
+import "./chunk-KCJFSVDN.mjs";
+import {
+  LISTENING_MODE_COMMAND_TYPE
+} from "./chunk-AUJEUKVM.mjs";
+import "./chunk-SN3STAO2.mjs";
+import "./chunk-PXKGKVGW.mjs";
 
 // src/local/session.ts
 import { randomUUID } from "node:crypto";

package/dist/chunk-7G2G4E4U.mjs

@@ -0,0 +1,236 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  listChannels,
+  readCursor,
+  readEntries,
+  readListeningMode
+} from "./chunk-T7YRVE43.mjs";
+import {
+  CURSOR_WORKSPACE_ENV,
+  cursorSessionId
+} from "./chunk-VUE2DDYY.mjs";
+import {
+  SESSION_ID_PATTERN,
+  readJson,
+  readStatus,
+  sessionFiles,
+  writeJsonAtomic
+} from "./chunk-KCJFSVDN.mjs";
+import {
+  HARNESSES
+} from "./chunk-SN3STAO2.mjs";
+
+// src/watch.ts
+import * as fs from "node:fs/promises";
+import { watch as watchDirectory } from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+
+// src/mcp/session-id.ts
+var isHarness = (value) => HARNESSES.includes(value);
+function resolveHarness(argv, env) {
+  const index = argv.indexOf("--harness");
+  if (index !== -1) {
+    const value = argv[index + 1];
+    return isHarness(value) ? value : "invalid";
+  }
+  if (isHarness(env.KHALA_MCP_HARNESS)) return env.KHALA_MCP_HARNESS;
+  return env.CLAUDE_CODE_SESSION_ID !== void 0 ? "claude" : "codex";
+}
+function resolveSessionId(harness, meta, env) {
+  const value = harness === "claude" ? env.CLAUDE_CODE_SESSION_ID : harness === "cursor" ? cursorSessionId(env[CURSOR_WORKSPACE_ENV]) : typeof meta?.threadId === "string" ? meta.threadId : env.CODEX_THREAD_ID;
+  return typeof value === "string" && value.match(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)?.[0] === value ? value : null;
+}
+
+// src/watch.ts
+var MARKER = "monitor.json";
+var OBSERVATION = "monitor-cursor.json";
+var NONCE_PATTERN = /^[a-f0-9-]{36}$/;
+var leaseFile = (files, nonce) => path.join(files.dir, `monitor-${nonce}.json`);
+async function monitorArmed(files) {
+  const owner = await readJson(path.join(files.dir, MARKER));
+  if (!owner || !Number.isSafeInteger(owner.pid) || owner.pid <= 0 || typeof owner.nonce !== "string" || !NONCE_PATTERN.test(owner.nonce)) return false;
+  if ((await readJson(leaseFile(files, owner.nonce)))?.nonce !== owner.nonce) return false;
+  try {
+    process.kill(owner.pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function mentions(entry, name) {
+  if (!name) return false;
+  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`(?<![\\p{L}\\p{N}_])@?${escaped}(?![\\p{L}\\p{N}_])`, "iu").test(entry.body);
+}
+function channelLabel(name) {
+  return Array.from(name.replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, " ").trim()).slice(0, 80).join("");
+}
+async function watchSession(files, io) {
+  const nonce = randomUUID();
+  let watcher;
+  let timer;
+  let running;
+  let dirty = false;
+  let done = false;
+  let code = 0;
+  let finish;
+  const finished = new Promise((resolve) => {
+    finish = resolve;
+  });
+  const stop = (exit = 0) => {
+    done = true;
+    code = exit;
+    watcher?.close();
+    clearInterval(timer);
+    finish();
+  };
+  const abort = () => stop();
+  try {
+    const status = await readStatus(files);
+    const initialSession = await readJson(files.session);
+    if (!["connected", "send_failed"].includes(status?.state ?? "") || !initialSession && !(await listChannels(files)).length) return 0;
+    const initialDelivered = /* @__PURE__ */ new Map();
+    const seedBaseline = async (target, session) => {
+      initialDelivered.set(target.dir, {
+        identity: JSON.stringify([session.roomId, session.userId]),
+        cursor: await readCursor(target)
+      });
+    };
+    if (initialSession) await seedBaseline(files, initialSession);
+    for (const channel of await listChannels(files)) {
+      const session = await readJson(channel.files.session);
+      if (session) await seedBaseline(channel.files, session);
+    }
+    const evaluate = async () => {
+      const ownsSession = async () => {
+        const owner = await readJson(path.join(files.dir, MARKER));
+        const status2 = await readJson(files.status);
+        return owner?.nonce === nonce && !["disconnected", "closed"].includes(status2?.state ?? "");
+      };
+      if (!await ownsSession()) {
+        stop();
+        return;
+      }
+      for (const channel of await listChannels(files)) {
+        const target = channel.files;
+        const session = await readJson(target.session);
+        const status2 = await readStatus(target);
+        if (!session || session.roomId !== channel.roomId || typeof session.userId !== "string" || !["connected", "send_failed"].includes(status2?.state ?? "")) continue;
+        const identity = JSON.stringify([session.roomId, session.userId]);
+        if (initialDelivered.get(target.dir)?.identity !== identity) {
+          await seedBaseline(target, session);
+        }
+        const mode = await readListeningMode(target);
+        const entries = await readEntries(target);
+        const observed = await readJson(path.join(target.dir, OBSERVATION));
+        const position = observed?.userId === session.userId && observed?.roomId === session.roomId && Number.isSafeInteger(observed.count) && observed.count >= 0 && observed.count <= entries.length && (observed.count === 0 || entries[observed.count - 1]?.eventId === observed.lastEventId) ? observed.count : 0;
+        const baseline = initialDelivered.get(target.dir).cursor;
+        const initialCount = baseline.deliveredCount === 0 || entries[baseline.deliveredCount - 1]?.eventId === baseline.lastDeliveredEventId ? baseline.deliveredCount : 0;
+        const fresh = entries.slice(Math.max(initialCount, position));
+        const latestMode = await readListeningMode(target);
+        const latestSession = await readJson(target.session);
+        const latestStatus = await readStatus(target);
+        if (!await ownsSession()) {
+          stop();
+          return;
+        }
+        if (latestSession?.userId !== session.userId || latestSession?.roomId !== session.roomId || !["connected", "send_failed"].includes(latestStatus?.state ?? "")) continue;
+        const messages = fresh.filter((entry) => entry.kind === "message" && entry.sender !== session.userId && entry.roomId === session.roomId);
+        if (!done && mode !== "async" && latestMode !== "async" && messages.length) {
+          const count = messages.filter((entry) => mentions(entry, latestStatus?.displayName)).length;
+          io.write(`khala: ${messages.length} new message${messages.length === 1 ? "" : "s"} in #${channelLabel(latestStatus?.channelName ?? channel.channelName ?? "channel")} (${count} mentions you)
+`);
+        }
+        if (position !== entries.length && !done && await ownsSession() && JSON.stringify(await readJson(target.session)) === JSON.stringify(latestSession)) {
+          try {
+            await writeJsonAtomic(path.join(target.dir, OBSERVATION), {
+              userId: session.userId,
+              roomId: session.roomId,
+              count: entries.length,
+              lastEventId: entries.at(-1)?.eventId ?? null
+            });
+          } catch (error) {
+            if (await readJson(target.session)) throw error;
+          }
+        }
+      }
+    };
+    const notify = () => {
+      if (done) return;
+      dirty = true;
+      if (running) return;
+      running = (async () => {
+        do {
+          dirty = false;
+          await evaluate();
+        } while (dirty && !done);
+      })().catch(() => stop(1)).finally(() => {
+        running = void 0;
+        if (dirty && !done) notify();
+      });
+    };
+    await writeJsonAtomic(leaseFile(files, nonce), { nonce, pid: process.pid });
+    await writeJsonAtomic(path.join(files.dir, MARKER), { nonce, pid: process.pid });
+    watcher = watchDirectory(files.dir, (_event, filename) => {
+      if (filename === null || [MARKER, "inbox.jsonl", "cursor.json", "mode.json", "session.json", "status.json"].includes(String(filename))) notify();
+    });
+    watcher.on("error", () => stop(1));
+    timer = setInterval(notify, 100);
+    io.signal.addEventListener("abort", abort, { once: true });
+    if (io.signal.aborted) stop();
+    else notify();
+    await finished;
+    await running;
+    return code;
+  } finally {
+    clearInterval(timer);
+    watcher?.close();
+    io.signal.removeEventListener("abort", abort);
+    await fs.unlink(leaseFile(files, nonce)).catch((error) => {
+      if (error.code !== "ENOENT") throw error;
+    });
+  }
+}
+var WATCH_USAGE = "usage: khala watch [--harness claude|codex|cursor --session <id>]";
+async function run(argv) {
+  if (argv.length === 1 && ["--help", "-h"].includes(argv[0])) {
+    console.log(WATCH_USAGE);
+    return 0;
+  }
+  const invalid = (reason) => {
+    console.error(`khala: ${reason}
+${WATCH_USAGE}`);
+    return 1;
+  };
+  if (argv.length !== 0 && !(argv.length === 2 && argv[0] === "--session") && !(argv.length === 4 && argv[0] === "--harness" && argv[2] === "--session")) return invalid("invalid_arguments");
+  const harness = resolveHarness(argv, process.env);
+  if (harness === "invalid") return invalid("invalid_harness");
+  const index = argv.indexOf("--session");
+  const id = index === -1 ? resolveSessionId(harness, void 0, process.env) : argv[index + 1];
+  if (!id) return invalid("session_unknown");
+  if (!SESSION_ID_PATTERN.test(id)) return invalid("invalid_session_id");
+  const files = sessionFiles(harness, id, process.env);
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  process.once("SIGTERM", stop);
+  process.once("SIGINT", stop);
+  try {
+    return await watchSession(files, { write: (line) => {
+      process.stdout.write(line);
+    }, signal: controller.signal });
+  } finally {
+    process.removeListener("SIGTERM", stop);
+    process.removeListener("SIGINT", stop);
+  }
+}
+
+export {
+  resolveHarness,
+  resolveSessionId,
+  monitorArmed,
+  mentions,
+  watchSession,
+  WATCH_USAGE,
+  run
+};

package/dist/chunk-AUJEUKVM.mjs

@@ -0,0 +1,121 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  decodeWith,
+  literal,
+  object,
+  readMatrixUserId,
+  version
+} from "./chunk-SN3STAO2.mjs";
+
+// ../contracts/src/delivery/decode.ts
+var MAX_IDENTIFIER_BYTES = 512;
+var DecodeFailure = class extends Error {
+  code;
+  field;
+  constructor(field, code) {
+    super(`${field || "<root>"}: ${code}`);
+    this.name = "DecodeFailure";
+    this.code = code;
+    this.field = field;
+  }
+};
+function fail(field, code) {
+  throw new DecodeFailure(field, code);
+}
+function decodeWith2(read) {
+  try {
+    return { ok: true, value: read() };
+  } catch (error) {
+    if (error instanceof DecodeFailure) return { ok: false, code: error.code, field: error.field };
+    return { ok: false, code: "invalid_field", field: "" };
+  }
+}
+function utf8Length(value) {
+  let bytes = 0;
+  for (const character of value) {
+    const codePoint = character.codePointAt(0) ?? 0;
+    if (codePoint < 128) bytes += 1;
+    else if (codePoint < 2048) bytes += 2;
+    else if (codePoint < 65536) bytes += 3;
+    else bytes += 4;
+  }
+  return bytes;
+}
+function isWellFormed(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) return false;
+      index += 1;
+    } else if (unit >= 56320 && unit <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+var CONTROL = /[\u0000-\u001f\u007f-\u009f]/;
+function identifier(input, field) {
+  if (typeof input !== "string") fail(field, "invalid_field");
+  if (!isWellFormed(input) || input.length === 0 || CONTROL.test(input)) fail(field, "invalid_field");
+  if (utf8Length(input) > MAX_IDENTIFIER_BYTES) fail(field, "limit_exceeded");
+  return input;
+}
+function literal2(input, field, allowed) {
+  if (!allowed.includes(input)) fail(field, "invalid_field");
+  return input;
+}
+
+// ../contracts/src/delivery/ids.ts
+function readId(input, field) {
+  return identifier(input, field);
+}
+var idDecoder = () => (input) => decodeWith2(() => readId(input, ""));
+var decodeOwnerId = idDecoder();
+var decodeParticipantId = idDecoder();
+var decodeDeviceId = idDecoder();
+var decodeBindingId = idDecoder();
+var decodeRoomId = idDecoder();
+var decodeEventId = idDecoder();
+var decodeCommandId = idDecoder();
+var decodeReleaseId = idDecoder();
+var decodeReceiptId = idDecoder();
+var decodeAuthorizationId = idDecoder();
+var decodeOperationId = idDecoder();
+var decodeCausalRootId = idDecoder();
+
+// ../contracts/src/delivery/listening-mode.ts
+var LISTENING_MODES = ["steer", "sync", "async"];
+function decodeListeningMode(input) {
+  return decodeWith2(() => literal2(input, "", LISTENING_MODES));
+}
+
+// ../contracts/src/m1/listening-mode.ts
+var LISTENING_MODE_COMMAND_TYPE = "com.khala.listening_mode.v1";
+var LISTENING_MODE_MEMBER_KEY = "com.khala.listening_mode";
+var DEFAULT_LISTENING_MODE = "sync";
+function decodeListeningModeCommand(input) {
+  return decodeWith(() => {
+    const r = object(input, "", ["v", "agent", "mode"]);
+    return {
+      v: version(r.field("v"), r.at("v")),
+      agent: readMatrixUserId(r.field("agent"), r.at("agent")),
+      mode: literal(r.field("mode"), r.at("mode"), LISTENING_MODES)
+    };
+  });
+}
+function memberListeningMode(content) {
+  const value = typeof content === "object" && content !== null ? content[LISTENING_MODE_MEMBER_KEY] : void 0;
+  const decoded = decodeListeningMode(value);
+  return decoded.ok ? decoded.value : DEFAULT_LISTENING_MODE;
+}
+
+export {
+  LISTENING_MODES,
+  decodeListeningMode,
+  LISTENING_MODE_COMMAND_TYPE,
+  LISTENING_MODE_MEMBER_KEY,
+  DEFAULT_LISTENING_MODE,
+  decodeListeningModeCommand,
+  memberListeningMode
+};