khala-cli 0.4.7 → 0.4.9

package/dist/chunk-NPSQNCOY.mjs

@@ -0,0 +1,590 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-7R3EIDGR.mjs";
+
+// ../contracts/src/m1/harness.ts
+init_define_KHALA_BUNDLE();
+var HARNESS_ID = /^[a-z][a-z0-9-]{1,23}$/;
+function isHarnessId(input) {
+  return typeof input === "string" && HARNESS_ID.exec(input)?.[0] === input;
+}
+var LEGACY_HARNESSES = ["claude", "codex", "cursor"];
+var HARNESS_REGISTRY = [
+  { id: "claude", displayName: "Claude Code", modelName: "Claude", logoKey: "claude", steer: true, sync: true, idleWake: "default", registered: true },
+  { id: "codex", displayName: "Codex", modelName: "Codex", logoKey: "codex", steer: true, sync: true, idleWake: "default", registered: true },
+  { id: "cursor", displayName: "Cursor", modelName: "Cursor", logoKey: "cursor", steer: true, sync: true, idleWake: "none", registered: true },
+  { id: "opencode", displayName: "OpenCode", modelName: "OpenCode", logoKey: "opencode", steer: true, sync: true, idleWake: "default", registered: true },
+  { id: "copilot", displayName: "Copilot CLI", modelName: "Copilot", logoKey: "copilot", steer: true, sync: true, idleWake: "opt-in", registered: true },
+  { id: "vscode", displayName: "Copilot (VS Code)", modelName: "VSCode", logoKey: "copilot", steer: true, sync: true, idleWake: "opt-in", registered: true },
+  { id: "gemini", displayName: "Gemini CLI", modelName: "Gemini", logoKey: "gemini", steer: true, sync: true, idleWake: "opt-in", registered: true },
+  // U29 establishes Antigravity capabilities after its spike.
+  { id: "antigravity", displayName: "Antigravity CLI", modelName: "Antigravity", logoKey: null, steer: false, sync: false, idleWake: "none", registered: true },
+  { id: "qwen", displayName: "Qwen Code", modelName: "Qwen", logoKey: "qwen", steer: true, sync: true, idleWake: "default", registered: true },
+  { id: "muse", displayName: "Muse Code", modelName: "Muse", logoKey: null, steer: true, sync: true, idleWake: "default", registered: true },
+  { id: "generic", displayName: "MCP agent", modelName: "Agent", logoKey: null, steer: false, sync: false, idleWake: "none", registered: true }
+];
+function harnessInfo(id) {
+  return HARNESS_REGISTRY.find((row) => row.id === id) ?? {
+    id,
+    displayName: id.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" "),
+    modelName: "Agent",
+    logoKey: null,
+    steer: false,
+    sync: false,
+    idleWake: "none",
+    registered: false
+  };
+}
+
+// src/state.ts
+init_define_KHALA_BUNDLE();
+import { constants } from "node:fs";
+import * as fs from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+
+// ../contracts/src/m1/agent-join.ts
+init_define_KHALA_BUNDLE();
+
+// ../contracts/src/messaging/decode.ts
+init_define_KHALA_BUNDLE();
+var MAX_IDENTIFIER_BYTES = 512;
+var DecodeFailure = class extends Error {
+  path;
+  code;
+  constructor(path2, code) {
+    super(`${path2 || "<root>"}: ${code}`);
+    this.name = "DecodeFailure";
+    this.path = path2;
+    this.code = code;
+  }
+};
+function fail(path2, code) {
+  throw new DecodeFailure(path2, 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 = (path2, key) => typeof key === "number" ? `${path2}[${key}]` : path2 ? `${path2}.${key}` : key;
+function object(input, path2, keys) {
+  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");
+  const record = input;
+  for (const key of Object.keys(record)) if (!keys.includes(key)) fail(join(path2, key), "unknown_field");
+  for (const key of keys) if (!Object.hasOwn(record, key)) fail(join(path2, key), "missing_field");
+  return { path: path2, field: (key) => record[key], at: (key) => join(path2, key) };
+}
+function array(input, path2) {
+  if (!Array.isArray(input)) fail(path2, "wrong_type");
+  return input;
+}
+function elementPath(path2, index) {
+  return join(path2, 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, path2, maxBytes) {
+  if (typeof input !== "string") fail(path2, "wrong_type");
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 0) fail(path2, "invalid_limits");
+  if (!isWellFormed(input)) fail(path2, "malformed_unicode");
+  if (utf8Length(input) > maxBytes) fail(path2, "too_long");
+  if (input.includes("\0")) fail(path2, "control_character");
+  return input;
+}
+function label(input, path2, maxBytes) {
+  const value = text(input, path2, maxBytes);
+  if (CONTROL.test(value)) fail(path2, "control_character");
+  return value;
+}
+function displayText(input, path2, maxBytes) {
+  const value = label(input, path2, maxBytes);
+  if (INVISIBLE.test(value)) fail(path2, "control_character");
+  return value;
+}
+function identifier(input, path2) {
+  const value = label(input, path2, MAX_IDENTIFIER_BYTES);
+  if (value.length === 0) fail(path2, "empty");
+  return value;
+}
+function nullable(input, read) {
+  return input === null ? null : read(input);
+}
+function literal(input, path2, allowed) {
+  if (!allowed.includes(input)) fail(path2, typeof input === typeof allowed[0] ? "invalid_value" : "wrong_type");
+  return input;
+}
+function version(input, path2) {
+  if (input !== 1) fail(path2, "unsupported_version");
+  return 1;
+}
+function safeInteger(input, path2) {
+  if (typeof input !== "number") fail(path2, "wrong_type");
+  if (!Number.isSafeInteger(input)) fail(path2, "unsafe_integer");
+  if (input < 0) fail(path2, "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, path2) {
+  if (typeof input !== "string") fail(path2, "wrong_type");
+  const match = UTC_TIMESTAMP.exec(input);
+  if (!match) fail(path2, "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(path2, "invalid_value");
+  return input;
+}
+
+// ../contracts/src/messaging/agent-names.ts
+init_define_KHALA_BUNDLE();
+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 M1_LABEL_MAX_BYTES = 512;
+var agentConfirmPagePath = (id) => `/agent/confirm?joinId=${encodeURIComponent(id)}`;
+function readHarness(input, path2) {
+  if (typeof input !== "string") fail(path2, "wrong_type");
+  if (!isHarnessId(input)) fail(path2, "invalid_value");
+  return input;
+}
+function readHttpUrl(input, path2) {
+  if (typeof input !== "string") fail(path2, "wrong_type");
+  let url;
+  try {
+    url = new URL(input);
+  } catch {
+    fail(path2, "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(path2, "invalid_value");
+  return input;
+}
+function readMatrixUserId(input, path2) {
+  const value = identifier(input, path2);
+  if (!/^@[^\s:]+:\S+$/u.test(value)) fail(path2, "invalid_value");
+  return value;
+}
+function readRoomId(input, path2) {
+  const value = identifier(input, path2);
+  if (!/^!\S+$/u.test(value)) fail(path2, "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);
+
+// src/harness/proc.ts
+init_define_KHALA_BUNDLE();
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var validPid = (pid) => Number.isSafeInteger(pid) && pid > 0;
+function startToken(value) {
+  return value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-");
+}
+function parseLinuxStat(pid, text2) {
+  const open2 = text2.indexOf("(");
+  const close = text2.lastIndexOf(")");
+  if (!validPid(pid) || open2 < 0 || close < open2 || Number(text2.slice(0, open2).trim()) !== pid) return null;
+  const fields = text2.slice(close + 1).trim().split(/\s+/);
+  if (fields[0] === "Z" || fields[0] === "X") return null;
+  const ppid = Number(fields[1]);
+  const startTime = fields[19];
+  if (!Number.isSafeInteger(ppid) || ppid < 0 || !startTime || !/^\d+$/.test(startTime)) return null;
+  return { pid, ppid, startTime, command: text2.slice(open2 + 1, close) };
+}
+function parseDarwinPs(pid, text2) {
+  const match = text2.trim().match(/^(\d+)\s+([A-Za-z]{3}\s+[A-Za-z]{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+\d{4})\s+(.+)$/);
+  if (!validPid(pid) || !match) return null;
+  return { pid, ppid: Number(match[1]), startTime: startToken(match[2]), command: match[3] };
+}
+function csvFields(line) {
+  const fields = [];
+  let value = "";
+  let quoted = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (char === '"') {
+      if (quoted && line[i + 1] === '"') {
+        value += '"';
+        i++;
+      } else quoted = !quoted;
+    } else if (char === "," && !quoted) {
+      fields.push(value);
+      value = "";
+    } else value += char;
+  }
+  if (quoted) return null;
+  fields.push(value);
+  return fields;
+}
+function parseWindowsCsv(text2, pid) {
+  if (!validPid(pid)) return null;
+  const lines = text2.replace(/^\uFEFF/, "").split(/\r?\n/).filter((line) => line.trim() && !line.startsWith("#"));
+  const headers = csvFields(lines[0] ?? "");
+  if (!headers) return null;
+  for (const line of lines.slice(1)) {
+    const values = csvFields(line);
+    if (!values) continue;
+    const field = (name) => values[headers.indexOf(name)] ?? "";
+    if (Number(field("ProcessId")) !== pid) continue;
+    const ppid = Number(field("ParentProcessId"));
+    const startTime = startToken(field("CreationDate"));
+    const command = field("Name");
+    if (!field("ParentProcessId") || !Number.isSafeInteger(ppid) || ppid < 0 || !startTime || !command) return null;
+    return { pid, ppid, startTime, command };
+  }
+  return null;
+}
+async function readProcess(pid) {
+  if (!validPid(pid)) return null;
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    if (error.code !== "EPERM") return null;
+  }
+  try {
+    if (process.platform === "linux") return parseLinuxStat(pid, await readFile(`/proc/${pid}/stat`, "utf8"));
+    if (process.platform === "darwin") {
+      const { stdout } = await execFileAsync("ps", ["-o", "ppid=,lstart=,comm=", "-p", String(pid)], { env: { ...process.env, LC_ALL: "C" }, timeout: 5e3 });
+      return parseDarwinPs(pid, stdout);
+    }
+    if (process.platform === "win32") {
+      const script = `Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' | Select-Object ProcessId,ParentProcessId,@{Name='CreationDate';Expression={$_.CreationDate.ToUniversalTime().ToString('o')}},Name | ConvertTo-Csv -NoTypeInformation`;
+      const { stdout } = await execFileAsync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { timeout: 5e3 });
+      return parseWindowsCsv(stdout, pid);
+    }
+  } catch {
+  }
+  return null;
+}
+async function* walkAncestors(pid, read = readProcess) {
+  const seen = /* @__PURE__ */ new Set([pid]);
+  let current = await read(pid);
+  while (current && validPid(current.ppid) && !seen.has(current.ppid)) {
+    seen.add(current.ppid);
+    current = await read(current.ppid);
+    if (current) yield current;
+  }
+}
+async function ancestors(pid, read = readProcess) {
+  const result = [];
+  for await (const parent of walkAncestors(pid, read)) result.push(parent);
+  return result;
+}
+async function nearestNonShellAncestor(pid, read = readProcess) {
+  for await (const ancestor of walkAncestors(pid, read)) {
+    const name = ancestor.command.split(/[\\/]/).pop()?.replace(/^-/, "").toLowerCase() ?? "";
+    if (!/^(?:sh|bash|dash|zsh|fish|ksh|csh|tcsh|ash|cmd(?:\.exe)?|powershell(?:\.exe)?|pwsh(?:\.exe)?)$/.test(name)) return ancestor;
+  }
+  return null;
+}
+function cachedProcessReader(read = readProcess) {
+  const cache = /* @__PURE__ */ new Map();
+  return (pid) => {
+    let result = cache.get(pid);
+    if (!result) {
+      result = read(pid);
+      cache.set(pid, result);
+    }
+    return result;
+  };
+}
+
+// src/state.ts
+var SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+var StateError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.name = "StateError";
+    this.code = code;
+  }
+};
+var WINDOWS = process.platform === "win32";
+async function renameWithRetry(from, to) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await fs.rename(from, to);
+      return;
+    } catch (error) {
+      const code = error.code;
+      if (!WINDOWS || attempt >= 20 || !["EPERM", "EACCES", "EBUSY"].includes(code ?? "")) throw error;
+      await new Promise((resolve) => setTimeout(resolve, 10 + attempt * 5));
+    }
+  }
+}
+function stateRoot(env = process.env) {
+  const base = env.XDG_STATE_HOME && path.isAbsolute(env.XDG_STATE_HOME) ? env.XDG_STATE_HOME : path.join(WINDOWS ? os.homedir() : env.HOME ?? os.homedir(), ".local", "state");
+  return path.join(base, "khala");
+}
+function filesForDir(dir) {
+  return { dir, mode: path.join(dir, "mode.json"), join: path.join(dir, "join.json"), session: path.join(dir, "session.json"), inbox: path.join(dir, "inbox.jsonl"), cursor: path.join(dir, "cursor.json"), status: path.join(dir, "status.json") };
+}
+function stateKey(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 24);
+}
+function channelsDir(files) {
+  return path.join(files.dir, "channels");
+}
+function channelFiles(files, roomId) {
+  return filesForDir(path.join(channelsDir(files), stateKey(roomId)));
+}
+function joinFilePath(files, key) {
+  if (!/^[a-f0-9]{24}$/.test(key)) throw new StateError("storage_failed");
+  return path.join(files.dir, "joins", `${key}.json`);
+}
+async function writeJoinFile(files, link, join2) {
+  const file = joinFilePath(files, stateKey(link));
+  await ensureStateDir(path.dirname(file));
+  await writeJsonAtomic(file, join2);
+}
+async function readJoinFile(files, link) {
+  const file = joinFilePath(files, stateKey(link));
+  await ensureStateDir(path.dirname(file));
+  return readJson(file);
+}
+async function removeJoinFile(files, link) {
+  const file = joinFilePath(files, stateKey(link));
+  await ensureStateDir(path.dirname(file));
+  try {
+    await fs.unlink(file);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw new StateError("storage_failed");
+  }
+}
+function sessionFiles(harness, sessionId, env) {
+  if (!isHarnessId(harness) || !SESSION_ID_PATTERN.test(sessionId)) throw new StateError("invalid_session_id");
+  return filesForDir(path.join(stateRoot(env), harness, sessionId));
+}
+function resolveStateDir(harness, sessionId, env) {
+  return sessionFiles(harness, sessionId, env).dir;
+}
+function khalaRootOf(dir) {
+  const resolved = path.resolve(dir);
+  const current = stateRoot();
+  const inside = path.relative(current, resolved);
+  if (inside !== ".." && !inside.startsWith(".." + path.sep) && !path.isAbsolute(inside)) return current;
+  const ancestors2 = [];
+  for (let current2 = resolved; ; current2 = path.dirname(current2)) {
+    ancestors2.unshift(current2);
+    if (path.dirname(current2) === current2) break;
+  }
+  for (const candidate of ancestors2) {
+    if (path.basename(candidate) !== "khala") continue;
+    const first = path.relative(candidate, resolved).split(path.sep)[0] ?? "";
+    if (first === "" || first === "local" || isHarnessId(first)) return candidate;
+  }
+  return resolved;
+}
+async function checkPrivateDir(directory) {
+  try {
+    await fs.mkdir(directory, { mode: 448 });
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  const stat2 = await fs.lstat(directory);
+  if (!stat2.isDirectory() || stat2.isSymbolicLink() || !WINDOWS && (stat2.mode & 63) !== 0 || typeof process.getuid === "function" && stat2.uid !== process.getuid()) throw new StateError("unsafe_state_dir");
+}
+async function ensureStateDir(dir) {
+  try {
+    const root = khalaRootOf(dir);
+    const parent = path.dirname(root);
+    await fs.mkdir(parent, { recursive: true });
+    if (!(await fs.stat(parent)).isDirectory()) throw new StateError("unsafe_state_dir");
+    let directory = root;
+    await checkPrivateDir(directory);
+    const relative = path.relative(root, path.resolve(dir));
+    for (const component of relative ? relative.split(path.sep) : []) {
+      directory = path.join(directory, component);
+      await checkPrivateDir(directory);
+    }
+  } catch (error) {
+    if (error instanceof StateError) throw error;
+    throw new StateError("storage_failed");
+  }
+}
+async function openSessionDir(harness, sessionId, env) {
+  const files = sessionFiles(harness, sessionId, env);
+  await ensureStateDir(files.dir);
+  return files;
+}
+async function writeJsonAtomic(file, value) {
+  const dir = path.dirname(file);
+  const temporary = path.join(dir, `.${path.basename(file)}-${randomUUID()}.tmp`);
+  let handle;
+  try {
+    handle = await fs.open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 384);
+    await handle.writeFile(JSON.stringify(value) + "\n", "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await renameWithRetry(temporary, file);
+    if (!WINDOWS) {
+      const directory = await fs.open(dir, constants.O_RDONLY);
+      try {
+        await directory.sync();
+      } finally {
+        await directory.close();
+      }
+    }
+  } catch {
+    throw new StateError("storage_failed");
+  } finally {
+    await handle?.close().catch(() => void 0);
+    await fs.unlink(temporary).catch(() => void 0);
+  }
+}
+async function readJson(file) {
+  let content;
+  try {
+    content = await fs.readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw new StateError("storage_failed");
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+var processIdentity;
+async function ownStatus(value) {
+  if (!value || typeof value !== "object" || !("state" in value) || !["connected", "send_failed"].includes(String(value.state))) return value;
+  const owner = await (processIdentity ??= readProcess(process.pid));
+  return owner ? { ...value, owner: { pid: owner.pid, startTime: owner.startTime } } : value;
+}
+async function readStatus(files, read = readProcess) {
+  const status = await readJson(files.status);
+  if (!status || !["connected", "send_failed"].includes(status.state)) return status;
+  const owner = status.owner;
+  const writer = owner && Number.isSafeInteger(owner.pid) && owner.pid > 0 && typeof owner.startTime === "string" ? await read(owner.pid) : null;
+  return writer && writer.startTime === owner?.startTime ? status : { ...status, state: "disconnected", detail: "process_exited" };
+}
+async function readWatcherStatus(files, read = readProcess, now = () => /* @__PURE__ */ new Date()) {
+  const status = await readJson(files.status);
+  if (!status || !["connected", "send_failed"].includes(status.state)) return status;
+  if (status.heartbeatAt !== void 0) {
+    const age = now().getTime() - Date.parse(status.heartbeatAt);
+    return Number.isFinite(age) && age >= 0 && age < 6e4 ? status : { ...status, state: "disconnected", detail: "heartbeat_stale" };
+  }
+  const owner = status.owner;
+  const writer = owner && Number.isSafeInteger(owner.pid) && owner.pid > 0 && typeof owner.startTime === "string" ? await read(owner.pid) : null;
+  return writer && writer.startTime !== owner?.startTime ? { ...status, state: "disconnected", detail: "process_exited" } : status;
+}
+async function writeStateFile(dir, name, value) {
+  if (!["join.json", "session.json", "cursor.json", "status.json", "mode.json", "rejoin.json", "channel.json", "resume.json"].includes(name)) throw new StateError("storage_failed");
+  await writeJsonAtomic(path.join(dir, name), name === "status.json" ? await ownStatus(value) : value);
+}
+function readStateFile(dir, name) {
+  if (!/^[a-z]+\.json$/.test(name)) throw new StateError("storage_failed");
+  return readJson(path.join(dir, name));
+}
+async function removeStateFile(dir, name) {
+  if (!/^[a-z]+\.json$/.test(name) && name !== "inbox.jsonl") throw new StateError("storage_failed");
+  try {
+    await fs.unlink(path.join(dir, name));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw new StateError("storage_failed");
+  }
+}
+var TERMINAL_SESSION_DETAILS = ["left", "removed", "revoked", "unauthorized", "channel_deleted"];
+
+export {
+  isHarnessId,
+  LEGACY_HARNESSES,
+  HARNESS_REGISTRY,
+  harnessInfo,
+  fail,
+  decodeWith,
+  object,
+  array,
+  elementPath,
+  utf8Length,
+  isWellFormed,
+  text,
+  label,
+  displayText,
+  identifier,
+  nullable,
+  literal,
+  version,
+  safeInteger,
+  utcTimestamp,
+  reserved,
+  validateAgentName,
+  M1_LABEL_MAX_BYTES,
+  agentConfirmPagePath,
+  readHarness,
+  readHttpUrl,
+  readMatrixUserId,
+  readRoomId,
+  validAgentSessionId,
+  validAgentRejoinSecret,
+  readProcess,
+  walkAncestors,
+  ancestors,
+  nearestNonShellAncestor,
+  cachedProcessReader,
+  SESSION_ID_PATTERN,
+  StateError,
+  stateRoot,
+  filesForDir,
+  stateKey,
+  channelsDir,
+  channelFiles,
+  writeJoinFile,
+  readJoinFile,
+  removeJoinFile,
+  sessionFiles,
+  resolveStateDir,
+  ensureStateDir,
+  openSessionDir,
+  writeJsonAtomic,
+  readJson,
+  readStatus,
+  readWatcherStatus,
+  writeStateFile,
+  readStateFile,
+  removeStateFile,
+  TERMINAL_SESSION_DETAILS
+};

package/dist/chunk-P3YIN7G7.mjs

@@ -0,0 +1,26 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  WAKE_USAGE,
+  cli_default,
+  consentLine,
+  runWake,
+  sessionIds,
+  setWake
+} from "./chunk-BEO7WIIM.mjs";
+import "./chunk-XUCWSYVS.mjs";
+import "./chunk-ITFD3JZS.mjs";
+import "./chunk-QKWEZXR3.mjs";
+import "./chunk-NIX5F4LT.mjs";
+import "./chunk-NGSYOVQ4.mjs";
+import "./chunk-TANCKTDK.mjs";
+import "./chunk-NPSQNCOY.mjs";
+import "./chunk-K7V7X6WU.mjs";
+import "./chunk-7R3EIDGR.mjs";
+export {
+  WAKE_USAGE,
+  consentLine,
+  cli_default as default,
+  runWake,
+  sessionIds,
+  setWake
+};