khala-cli 0.4.2 → 0.4.5

package/dist/{chunk-7MQAMABY.mjs → chunk-RSDOTTZQ.mjs}

@@ -1,11 +1,11 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  bundle
+} from "./chunk-OLZ62X7S.mjs";
 import {
   CURSOR_WORKSPACE_ENV
 } from "./chunk-VUE2DDYY.mjs";
-import {
-  bundle
-} from "./chunk-RW3DXWNC.mjs";
-import "./chunk-A3LJU4JA.mjs";
+import "./chunk-PXKGKVGW.mjs";
 
 // src/install/main.ts
 import { spawnSync } from "node:child_process";

package/dist/chunk-SN3STAO2.mjs

@@ -0,0 +1,190 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+
+// ../contracts/src/messaging/decode.ts
+var MAX_IDENTIFIER_BYTES = 512;
+var DecodeFailure = class extends Error {
+  path;
+  code;
+  constructor(path, code) {
+    super(`${path || "<root>"}: ${code}`);
+    this.name = "DecodeFailure";
+    this.path = path;
+    this.code = code;
+  }
+};
+function fail(path, code) {
+  throw new DecodeFailure(path, code);
+}
+function decodeWith(read) {
+  try {
+    return { ok: true, value: read() };
+  } catch (error) {
+    if (error instanceof DecodeFailure) return { ok: false, error: { path: error.path, code: error.code } };
+    throw error;
+  }
+}
+var join = (path, key) => typeof key === "number" ? `${path}[${key}]` : path ? `${path}.${key}` : key;
+function object(input, path, keys) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) fail(path, "not_object");
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== Object.prototype && prototype !== null) fail(path, "not_object");
+  const record = input;
+  for (const key of Object.keys(record)) if (!keys.includes(key)) fail(join(path, key), "unknown_field");
+  for (const key of keys) if (!Object.hasOwn(record, key)) fail(join(path, key), "missing_field");
+  return { path, field: (key) => record[key], at: (key) => join(path, key) };
+}
+function array(input, path) {
+  if (!Array.isArray(input)) fail(path, "wrong_type");
+  return input;
+}
+function elementPath(path, index) {
+  return join(path, index);
+}
+function utf8Length(value) {
+  let bytes = 0;
+  for (const char of value) {
+    const code = char.codePointAt(0) ?? 0;
+    bytes += code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 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]/;
+var INVISIBLE = /[\u061c\u200b\u200e\u200f\u202a-\u202e\u2060\u2066-\u2069\ufeff]/;
+function text(input, path, maxBytes) {
+  if (typeof input !== "string") fail(path, "wrong_type");
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) fail(path, "invalid_limits");
+  if (!isWellFormed(input)) fail(path, "malformed_unicode");
+  if (utf8Length(input) > maxBytes) fail(path, "too_long");
+  if (input.includes("\0")) fail(path, "control_character");
+  return input;
+}
+function label(input, path, maxBytes) {
+  const value = text(input, path, maxBytes);
+  if (CONTROL.test(value)) fail(path, "control_character");
+  return value;
+}
+function displayText(input, path, maxBytes) {
+  const value = label(input, path, maxBytes);
+  if (INVISIBLE.test(value)) fail(path, "control_character");
+  return value;
+}
+function identifier(input, path) {
+  const value = label(input, path, MAX_IDENTIFIER_BYTES);
+  if (value.length === 0) fail(path, "empty");
+  return value;
+}
+function nullable(input, read) {
+  return input === null ? null : read(input);
+}
+function literal(input, path, allowed) {
+  if (!allowed.includes(input)) fail(path, typeof input === typeof allowed[0] ? "invalid_value" : "wrong_type");
+  return input;
+}
+function version(input, path) {
+  if (input !== 1) fail(path, "unsupported_version");
+  return 1;
+}
+function safeInteger(input, path) {
+  if (typeof input !== "number") fail(path, "wrong_type");
+  if (!Number.isSafeInteger(input)) fail(path, "unsafe_integer");
+  if (input < 0) fail(path, "invalid_value");
+  return input;
+}
+var UTC_TIMESTAMP = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?Z$/;
+function utcTimestamp(input, path) {
+  if (typeof input !== "string") fail(path, "wrong_type");
+  const match = UTC_TIMESTAMP.exec(input);
+  if (!match) fail(path, "invalid_value");
+  const [year, month, day, hour, minute, second] = match.slice(1).map(Number);
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCFullYear(year, month - 1, day);
+  date.setUTCHours(hour, minute, second, 0);
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day || date.getUTCHours() !== hour || date.getUTCMinutes() !== minute || date.getUTCSeconds() !== second) fail(path, "invalid_value");
+  return input;
+}
+
+// ../contracts/src/messaging/agent-names.ts
+var MAX_AGENT_NAME_BYTES = 80;
+var unsafe = /[\u0000-\u001f\u007f-\u009f\u061c\u200b-\u200f\u2028-\u202e\u2060-\u2069\ufeff]/u;
+var reserved = /\b(?:admin(?:istrator)?|system|khala|moderator|owner|human|security|support|official)\b/iu;
+function validateAgentName(input) {
+  if (typeof input !== "string") return { ok: false, error: "blank" };
+  const name = input.trim().normalize("NFC");
+  if (!name) return { ok: false, error: "blank" };
+  if (unsafe.test(name)) return { ok: false, error: "invalid_characters" };
+  if (new TextEncoder().encode(name).byteLength > MAX_AGENT_NAME_BYTES) return { ok: false, error: "too_long" };
+  if (reserved.test(name.normalize("NFKC"))) return { ok: false, error: "reserved" };
+  return { ok: true, name };
+}
+
+// ../contracts/src/m1/agent-join.ts
+var HARNESSES = ["claude", "codex", "cursor"];
+var M1_LABEL_MAX_BYTES = 512;
+var agentConfirmPagePath = (id) => `/agent/confirm?joinId=${encodeURIComponent(id)}`;
+function readHarness(input, path) {
+  return literal(input, path, HARNESSES);
+}
+function readHttpUrl(input, path) {
+  if (typeof input !== "string") fail(path, "wrong_type");
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    fail(path, "invalid_value");
+  }
+  if (url.username || url.password || url.hash || !(url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))) fail(path, "invalid_value");
+  return input;
+}
+function readMatrixUserId(input, path) {
+  const value = identifier(input, path);
+  if (!/^@[^\s:]+:\S+$/u.test(value)) fail(path, "invalid_value");
+  return value;
+}
+function readRoomId(input, path) {
+  const value = identifier(input, path);
+  if (!/^!\S+$/u.test(value)) fail(path, "invalid_value");
+  return value;
+}
+var validAgentSessionId = (value) => typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/u.test(value);
+var validAgentRejoinSecret = (value) => typeof value === "string" && /^[A-Za-z0-9_-]{43}$/u.test(value);
+
+export {
+  fail,
+  decodeWith,
+  object,
+  array,
+  elementPath,
+  utf8Length,
+  isWellFormed,
+  text,
+  label,
+  displayText,
+  identifier,
+  nullable,
+  literal,
+  version,
+  safeInteger,
+  utcTimestamp,
+  reserved,
+  validateAgentName,
+  HARNESSES,
+  M1_LABEL_MAX_BYTES,
+  agentConfirmPagePath,
+  readHarness,
+  readHttpUrl,
+  readMatrixUserId,
+  readRoomId,
+  validAgentSessionId,
+  validAgentRejoinSecret
+};

package/dist/{chunk-MHZWR4A3.mjs → chunk-SQXDATEC.mjs}

@@ -1,7 +1,7 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
   bundle
-} from "./chunk-RW3DXWNC.mjs";
+} from "./chunk-OLZ62X7S.mjs";
 
 // src/version.ts
 var KHALA_AGENT_VERSION = bundle?.version ?? "0.0.0";

package/dist/chunk-T7YRVE43.mjs

@@ -0,0 +1,238 @@
+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-KCJFSVDN.mjs";
+import {
+  DEFAULT_LISTENING_MODE,
+  decodeListeningMode
+} from "./chunk-AUJEUKVM.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 (present[2] && !destinationInbox && present[0] && await exists(nested.cursor)) {
+    if (await fs2.readFile(files.cursor, "utf8") !== await fs2.readFile(nested.cursor, "utf8")) {
+      throw new StateError("storage_failed");
+    }
+  }
+  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 };
+}
+
+// src/mode.ts
+async function readListeningMode(files) {
+  const content = await readJson(files.mode);
+  const decoded = decodeListeningMode(typeof content === "object" && content !== null ? content.mode : void 0);
+  return decoded.ok ? decoded.value : DEFAULT_LISTENING_MODE;
+}
+async function applyListeningMode(files, next, meta, now = () => /* @__PURE__ */ new Date()) {
+  const previous = await readListeningMode(files);
+  if (previous === "async" && next !== "async") {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const { cursor, entries } = await unread(files);
+      if (await advanceCursor(files, cursor, entries) !== "conflict") break;
+      if (attempt === 1) throw new StateError("storage_failed");
+    }
+  }
+  await writeJsonAtomic(files.mode, { mode: next, ...meta, updatedAt: now().toISOString() });
+  return { previous, next };
+}
+
+export {
+  readEntries,
+  readCursor,
+  unread,
+  advanceCursor,
+  appendInbox,
+  unreadCount,
+  channelKey,
+  listChannels,
+  migrateLegacy,
+  resolveChannel,
+  readListeningMode,
+  applyListeningMode
+};

package/dist/{chunk-BZ53MZEE.mjs → chunk-TZKEQIHP.mjs}

@@ -1,6 +1,8 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
-  LISTENING_MODES,
+  LISTENING_MODES
+} from "./chunk-AUJEUKVM.mjs";
+import {
   M1_LABEL_MAX_BYTES,
   array,
   decodeWith,
@@ -21,16 +23,18 @@ import {
   utcTimestamp,
   utf8Length,
   version
-} from "./chunk-N6LMHR7P.mjs";
+} from "./chunk-SN3STAO2.mjs";
 
 // src/client.ts
 var KhalaClientError = class extends Error {
-  code;
-  constructor(code, message) {
+  constructor(code, message, extra) {
     super(message ?? code);
+    this.extra = extra;
     this.name = "KhalaClientError";
     this.code = code;
   }
+  extra;
+  code;
 };
 
 // ../contracts/src/m1/colors.ts