khala-cli 0.4.8 → 0.4.10

package/dist/{chunk-H3K4GA2P.mjs → chunk-WPNMWNCL.mjs}

@@ -2,7 +2,7 @@ import { createRequire as __khalaCreateRequire } from 'node:module'; const requi
 import {
   parseChannelLink,
   resolveLocalOwnerName
-} from "./chunk-VAI7IUI4.mjs";
+} from "./chunk-VDZK4LW3.mjs";
 import {
   LOCAL_AGENT_DEVICE_PREFIX,
   LOCAL_IDLE_EXIT_MS,
@@ -32,26 +32,14 @@ import {
   normalizeInitials,
   olderHelperVersion,
   readHelperFile
-} from "./chunk-2DHIAFEV.mjs";
+} from "./chunk-SRZTHCXP.mjs";
+import "./chunk-HHEZVPRR.mjs";
 import {
   KHALA_AGENT_VERSION
-} from "./chunk-5LIE5GUU.mjs";
+} from "./chunk-XR625T3I.mjs";
 import {
   bundle
-} from "./chunk-APMWDF6B.mjs";
-import "./chunk-5GLTKWJ5.mjs";
-import {
-  CHANNEL_EVENT_TYPE,
-  decodeChannelEvent,
-  encodeChannelEvent,
-  memberRenameContent
-} from "./chunk-54XFVSEC.mjs";
-import {
-  StateError,
-  ensureStateDir,
-  readJson,
-  writeJsonAtomic
-} from "./chunk-CBPLCCRZ.mjs";
+} from "./chunk-G3NMB4PY.mjs";
 import {
   DEFAULT_LISTENING_MODE,
   LISTENING_MODE_COMMAND_TYPE,
@@ -59,29 +47,44 @@ import {
   decodeListeningMode,
   decodeListeningModeCommand,
   memberListeningMode
-} from "./chunk-IQJQ4RF5.mjs";
+} from "./chunk-4BP7V3OP.mjs";
+import {
+  CHANNEL_EVENT_TYPE,
+  decodeChannelEvent,
+  encodeChannelEvent,
+  memberRenameContent
+} from "./chunk-JKOJQTFT.mjs";
 import {
   LEGACY_HARNESSES,
+  StateError,
   agentConfirmPagePath,
   decodeWith,
+  ensureStateDir,
   isHarnessId,
   object,
+  readJson,
   utf8Length,
   validAgentRejoinSecret,
-  validAgentSessionId
-} from "./chunk-NKX3SLS7.mjs";
-import "./chunk-7HBRFY3Z.mjs";
+  validAgentSessionId,
+  writeJsonAtomic
+} from "./chunk-PN25BUQ4.mjs";
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
 
 // src/local/cli.ts
+init_define_KHALA_BUNDLE();
 import { setTimeout as sleepDefault } from "node:timers/promises";
 
 // src/local/serve.ts
+init_define_KHALA_BUNDLE();
 import { createHash as createHash3, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
 import { unlink } from "node:fs/promises";
 import path3 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/local/store.ts
+init_define_KHALA_BUNDLE();
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
@@ -564,6 +567,7 @@ async function openLocalStore(input) {
 }
 
 // src/local/http.ts
+init_define_KHALA_BUNDLE();
 import { createServer } from "node:http";
 import * as fs2 from "node:fs/promises";
 import path2 from "node:path";
@@ -838,9 +842,11 @@ function createHelperServer(options) {
 }
 
 // src/local/routes/agent-join.ts
+init_define_KHALA_BUNDLE();
 import { createHash as createHash2, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 
 // ../contracts/src/m1/channel-names.ts
+init_define_KHALA_BUNDLE();
 var key = (name) => name.trim().toLowerCase();
 function takenNames(names) {
   return new Set([...names].map(key));
@@ -970,7 +976,11 @@ function agentJoinRoutes() {
   ];
 }
 
+// src/local/routes/rooms.ts
+init_define_KHALA_BUNDLE();
+
 // src/local/wire.ts
+init_define_KHALA_BUNDLE();
 function legacyHarnessView(content) {
   if (!("harness" in content) || content.harness === void 0 || LEGACY_HARNESSES.includes(content.harness)) return content;
   const legacy = { ...content };
@@ -1191,6 +1201,7 @@ function roomRoutes() {
 }
 
 // src/local/routes/owner.ts
+init_define_KHALA_BUNDLE();
 var ID = /^[A-Za-z0-9._-]{1,64}$/u;
 var USER = /^@[^\s:]+:\S+$/u;
 var fail4 = (status, error2) => ({ status, json: { error: error2 } });
@@ -1382,6 +1393,7 @@ function ownerRoutes(options = {}) {
 }
 
 // src/local/routes/profile.ts
+init_define_KHALA_BUNDLE();
 var fail5 = (status, error2) => ({ status, json: { error: error2 } });
 var field = (body, key2) => decodeWith(() => object(body, "", [key2]).field(key2));
 var iso = (ctx) => new Date(ctx.now()).toISOString();

package/dist/chunk-WUDXHF2Q.mjs

@@ -0,0 +1,14 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
+
+// src/transport.ts
+init_define_KHALA_BUNDLE();
+var RESTORE_HISTORY_MAX_PAGES = 20;
+var startChannelSession = async (creds, options) => creds.transport === "local" ? (await import("./chunk-NDMFD5IM.mjs")).createLocalSession(creds) : (await import("./chunk-PJKI7SRI.mjs")).createAgentMatrixSession(creds, options);
+
+export {
+  RESTORE_HISTORY_MAX_PAGES,
+  startChannelSession
+};

package/dist/chunk-WZJ6DQJV.mjs

@@ -0,0 +1,19 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  ADAPTERS,
+  adapterFor,
+  createAdapterRegistry
+} from "./chunk-5JSGA6OB.mjs";
+import "./chunk-6AQVW5W7.mjs";
+import "./chunk-2AMWQ7RB.mjs";
+import "./chunk-4BP7V3OP.mjs";
+import "./chunk-OEV5DFLW.mjs";
+import "./chunk-JKOJQTFT.mjs";
+import "./chunk-PN25BUQ4.mjs";
+import "./chunk-ZSKLNZWZ.mjs";
+import "./chunk-EVT2DWNZ.mjs";
+export {
+  ADAPTERS,
+  adapterFor,
+  createAdapterRegistry
+};

package/dist/{chunk-5LIE5GUU.mjs → chunk-XR625T3I.mjs}

@@ -1,9 +1,13 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
   bundle
-} from "./chunk-APMWDF6B.mjs";
+} from "./chunk-G3NMB4PY.mjs";
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
 
 // src/version.ts
+init_define_KHALA_BUNDLE();
 var KHALA_AGENT_VERSION = bundle?.version ?? "0.0.0";
 
 export {

package/dist/chunk-ZSKLNZWZ.mjs

@@ -0,0 +1,224 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
+
+// src/wake/shared/nonce.ts
+init_define_KHALA_BUNDLE();
+import * as fs2 from "node:fs/promises";
+import path2 from "node:path";
+import { randomBytes as randomBytes3 } from "node:crypto";
+
+// src/wake/shared/rules.ts
+init_define_KHALA_BUNDLE();
+import { randomBytes } from "node:crypto";
+var CODEX_IDLE_WAKE_NOTICE = "Khala: channel messages are waiting. Continue.";
+function newNonce() {
+  return randomBytes(4).toString("hex");
+}
+function wakeLine(nonce) {
+  if (!/^[a-f0-9]{8}$/.test(nonce)) throw new Error("invalid_wake_nonce");
+  return `${CODEX_IDLE_WAKE_NOTICE} (k-${nonce})`;
+}
+
+// src/wake/shared/lock.ts
+init_define_KHALA_BUNDLE();
+import * as fs from "node:fs/promises";
+import path from "node:path";
+import { randomBytes as randomBytes2 } from "node:crypto";
+async function clearAbandonedLock(lock) {
+  let entries;
+  try {
+    entries = await fs.readdir(lock);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  for (const entry of entries) {
+    const owner = /^owner-(\d+)-[a-f0-9]{16}$/.exec(entry);
+    if (!owner) continue;
+    try {
+      process.kill(Number(owner[1]), 0);
+    } catch (error) {
+      if (error.code !== "ESRCH") continue;
+      await fs.rm(path.join(lock, entry), { force: true });
+    }
+  }
+  try {
+    await fs.rmdir(lock);
+  } catch (error) {
+    if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
+  }
+}
+async function withWakeLock(dir, name, work) {
+  await fs.mkdir(dir, { recursive: true, mode: 448 });
+  const lock = path.join(dir, name);
+  const owner = `owner-${process.pid}-${randomBytes2(8).toString("hex")}`;
+  const candidate = path.join(dir, `.${owner}`);
+  await fs.mkdir(candidate, { mode: 448 });
+  await fs.writeFile(path.join(candidate, owner), "", { mode: 384 });
+  let acquired = false;
+  try {
+    for (let tries = 0; tries < 200; tries++) {
+      try {
+        await fs.rename(candidate, lock);
+        acquired = true;
+        break;
+      } catch (error) {
+        if (!["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].includes(error.code ?? "")) throw error;
+      }
+      await clearAbandonedLock(lock);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  } finally {
+    if (!acquired) await fs.rm(candidate, { recursive: true, force: true });
+  }
+  if (!acquired) throw new Error("wake_state_locked");
+  try {
+    return await work();
+  } finally {
+    await fs.rm(path.join(lock, owner), { force: true });
+    try {
+      await fs.rmdir(lock);
+    } catch (error) {
+      if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
+    }
+  }
+}
+
+// src/wake/shared/nonce.ts
+async function readJson(file, fallback) {
+  try {
+    return JSON.parse(await fs2.readFile(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw error;
+  }
+}
+async function atomic(file, value) {
+  const temp = `${file}.${randomBytes3(8).toString("hex")}.tmp`;
+  try {
+    await fs2.writeFile(temp, JSON.stringify(value), { mode: 384 });
+    await fs2.rename(temp, file);
+  } finally {
+    await fs2.rm(temp, { force: true });
+  }
+}
+async function locked(dir, work) {
+  return withWakeLock(dir, "wake.lock", async () => {
+    const data = await readJson(path2.join(dir, "wake-journal.json"), { attempts: [], state: {} });
+    const before = JSON.stringify(data);
+    const result = work(data);
+    if (JSON.stringify(data) === before) return result;
+    await atomic(path2.join(dir, "wake-journal.json"), data);
+    await atomic(path2.join(dir, "wake-state.json"), data.state);
+    return result;
+  });
+}
+async function readWakeState(dir) {
+  return (await readJson(path2.join(dir, "wake-journal.json"), { attempts: [], state: {} })).state;
+}
+async function recordAttempt(dir, attempt) {
+  wakeLine(attempt.nonce);
+  if (!attempt.driver || ["__proto__", "constructor", "prototype"].includes(attempt.driver) || !Number.isFinite(attempt.at) || !Number.isFinite(attempt.deadline) || attempt.deadline <= attempt.at) throw new Error("invalid_wake_attempt");
+  await locked(dir, (data) => {
+    if (data.attempts.some((item) => item.nonce === attempt.nonce)) throw new Error("duplicate_wake_nonce");
+    data.attempts.push(attempt);
+  });
+}
+async function settleAttempts(dir, input) {
+  const snapshot = await readJson(path2.join(dir, "wake-journal.json"), { attempts: [], state: {} });
+  if (!snapshot.attempts.length) return [];
+  return locked(dir, (data) => {
+    const results = [];
+    const remaining = [];
+    const activityAt = typeof input.activity?.updatedAt === "number" ? input.activity.updatedAt : Date.parse(input.activity?.updatedAt ?? "");
+    for (const attempt of data.attempts) {
+      let status;
+      const baselineAt = typeof attempt.activityUpdatedAt === "number" ? attempt.activityUpdatedAt : attempt.activityUpdatedAt === void 0 ? attempt.at : Date.parse(attempt.activityUpdatedAt);
+      const verified = input.promptText?.includes(`(k-${attempt.nonce})`);
+      const activityChanged = input.activity && (input.activity.state !== "idle" || activityAt > baselineAt);
+      if (input.deferVerification && !activityChanged) attempt.verificationDeferred = true;
+      if (attempt.verification === "transcript") {
+        if (input.now >= attempt.deadline && input.activity?.state === "idle") status = "failure";
+      } else if (verified && input.verifiedAt !== void 0 && input.verifiedAt >= attempt.at && input.verifiedAt <= attempt.deadline) status = "success";
+      else if (attempt.verificationDeferred) {
+        if (verified && input.now <= attempt.deadline) status = "success";
+        else if (input.now >= attempt.deadline) status = activityChanged ? "void" : "failure";
+      } else if (activityChanged && !(attempt.startsActivity && input.activity?.state === "busy" && input.promptText === void 0)) status = "void";
+      else if (verified && input.verifiedAt === void 0 && input.now <= attempt.deadline) status = "success";
+      else if (input.now >= attempt.deadline && input.activity?.state === "idle") status = "failure";
+      else if (input.promptText !== void 0) status = "void";
+      if (!status) {
+        remaining.push(attempt);
+        continue;
+      }
+      results.push({ nonce: attempt.nonce, driver: attempt.driver, status });
+      if (status === "void") continue;
+      const prior = data.state[attempt.driver] ?? { failures: 0 };
+      if (status === "success") data.state[attempt.driver] = { failures: 0 };
+      else {
+        const failures = prior.failures + 1;
+        data.state[attempt.driver] = failures >= 2 ? { ...prior, failures, disabled: true, reason: "nonce_timeout", at: new Date(input.now).toISOString() } : { failures };
+      }
+    }
+    data.attempts = remaining;
+    return results;
+  });
+}
+async function cancelAttempt(dir, nonce) {
+  await locked(dir, (data) => {
+    data.attempts = data.attempts.filter((attempt) => attempt.nonce !== nonce);
+  });
+}
+async function failAttempt(dir, nonce, now) {
+  await locked(dir, (data) => {
+    const attempt = data.attempts.find((item) => item.nonce === nonce);
+    if (!attempt) return;
+    data.attempts = data.attempts.filter((item) => item.nonce !== nonce);
+    const prior = data.state[attempt.driver] ?? { failures: 0 };
+    const failures = prior.failures + 1;
+    data.state[attempt.driver] = failures >= 2 ? { ...prior, failures, disabled: true, reason: "nonce_timeout", at: new Date(now).toISOString() } : { failures };
+  });
+}
+async function resetWakeDriver(dir, driver) {
+  await locked(dir, (data) => {
+    delete data.state[driver];
+    data.attempts = data.attempts.filter((attempt) => attempt.driver !== driver);
+  });
+}
+async function takeWakeDisableNotices(dir) {
+  return locked(dir, (data) => {
+    const drivers = [];
+    for (const [driver, state] of Object.entries(data.state)) {
+      if (!state.disabled || state.noticeShown) continue;
+      state.noticeShown = true;
+      drivers.push(driver);
+    }
+    return drivers;
+  });
+}
+async function confirmWakeText(dir, driver, text, now) {
+  await locked(dir, (data) => {
+    data.attempts = data.attempts.filter((attempt) => {
+      if (attempt.driver !== driver || now > attempt.deadline || !text.includes(`(k-${attempt.nonce})`)) return true;
+      data.state[driver] = { failures: 0 };
+      return false;
+    });
+  });
+}
+
+export {
+  CODEX_IDLE_WAKE_NOTICE,
+  newNonce,
+  wakeLine,
+  withWakeLock,
+  readWakeState,
+  recordAttempt,
+  settleAttempts,
+  cancelAttempt,
+  failAttempt,
+  resetWakeDriver,
+  takeWakeDisableNotices,
+  confirmWakeText
+};

package/dist/iterm2_send.py

@@ -0,0 +1,56 @@
+"""Read only by default; guarded sends never activate a session or broadcast."""
+import json
+import re
+import sys
+
+
+async def operate(connection, uuid, text=None, expected=None):
+    import iterm2
+
+    app = await iterm2.async_get_app(connection)
+    session = app.get_session_by_id(uuid)
+    if session is None:
+        return {"reason": "iterm2_session_missing"}
+    screen = await session.async_get_screen_contents()
+    cursor = screen.cursor_coord
+    # ScreenContents uses absolute buffer coordinates, including lost history.
+    row = cursor.y - screen.windowed_coord_range.coord_range.start.y
+    if row < 0 or row >= screen.number_of_lines:
+        return {"reason": "iterm2_cursor_unavailable"}
+    contents = screen.line(row)
+    styled = ""
+    for column in range(session.grid_size.width):
+        try:
+            character = contents.string_at(column)
+        except IndexError:
+            break
+        style = contents.style_at(column)
+        styled += ("\x1b[2m" if style and style.faint else "\x1b[22m") + character
+    if re.sub(r"\x1b\[[0-9;]*m", "", styled) != contents.string:
+        return {"reason": "iterm2_style_unavailable"}
+    view = {"tty": await session.async_get_variable("tty"),
+            "cursorX": cursor.x, "cursorY": cursor.y,
+            "line": styled}
+    if text is None:
+        return view
+    # The TypeScript prompt guard approved this exact snapshot. A full literal
+    # pattern avoids translating JavaScript regex syntax or trusting a draft.
+    if (expected is None or view["tty"] != expected["tty"]
+            or view["cursorX"] != expected["cursorX"]
+            or view["cursorY"] != expected["cursorY"]
+            or re.fullmatch(re.escape(expected["line"]), view["line"]) is None):
+        return {"status": "not_empty"}
+    await session.async_send_text(text, suppress_broadcast=True)
+    return {"status": "sent"}
+
+
+if __name__ == "__main__":
+    import iterm2
+
+    async def main(connection):
+        expected = json.loads(sys.argv[3]) if len(sys.argv) > 3 else None
+        result = await operate(connection, sys.argv[1],
+                               sys.argv[2] if len(sys.argv) > 2 else None, expected)
+        print(json.dumps(result))
+
+    iterm2.run_until_complete(main)

package/dist/khala.mjs

@@ -2,14 +2,20 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
   KHALA_AGENT_VERSION
-} from "./chunk-5LIE5GUU.mjs";
-import "./chunk-APMWDF6B.mjs";
-import "./chunk-7HBRFY3Z.mjs";
+} from "./chunk-XR625T3I.mjs";
+import "./chunk-G3NMB4PY.mjs";
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
+
+// src/cli-bundle.ts
+init_define_KHALA_BUNDLE();
 
 // src/cli.ts
+init_define_KHALA_BUNDLE();
 var HOOK_NAME = /^[a-z][a-z0-9-]{0,31}$/;
 var STDIN_CAP = 1024 * 1024;
-var USAGE = "usage: khala mcp | khala watch [--harness claude|codex|cursor --session <id>] | khala hook <name> | khala local <command> | khala install codex | khala install cursor | khala install opencode | khala install mcp --print [--harness <id>] | khala --version";
+var USAGE = "usage: khala mcp | khala watch [--harness <id>] [--session <id>] | khala hook <name> | khala local <command> | khala install codex | khala install cursor | khala wake on|off|status [--driver <d>] [--harness <id>] [--json] | khala install copilot | khala install opencode | khala install gemini [--trust-tools] [--wake|--no-wake] [--uninstall] | khala install muse | khala install mcp --print [--harness <id>] | khala --version";
 async function readStdin() {
   if (process.stdin.isTTY) return "";
   const chunks = [];
@@ -31,8 +37,8 @@ async function runCli(argv, modules) {
     console.log(KHALA_AGENT_VERSION);
     return 0;
   }
-  if (cmd === "mcp" || cmd === "install" || cmd === "watch") {
-    const load = modules[cmd]();
+  if (cmd === "mcp" || cmd === "install" || cmd === "watch" || cmd === "wake") {
+    const load = modules[cmd]?.();
     if (!load) {
       console.error(`khala: ${cmd} not available`);
       return 1;
@@ -78,14 +84,15 @@ async function runCli(argv, modules) {
 
 // src/cli-bundle.ts
 var hooks = {
-  "session-start": () => import("./chunk-W6R4UJUQ.mjs"),
-  deliver: () => import("./chunk-VUSV2ADL.mjs"),
-  "claude-wake": () => import("./chunk-BKLW2SPG.mjs")
+  "session-start": () => import("./chunk-6J2PUM7L.mjs"),
+  deliver: () => import("./chunk-QDPJ4VT2.mjs"),
+  "claude-wake": () => import("./chunk-VAC3JTAV.mjs")
 };
 process.exitCode = await runCli(process.argv.slice(2), {
-  mcp: () => () => import("./chunk-RNDUFTBF.mjs"),
-  watch: () => () => import("./chunk-Z4JF2M5C.mjs"),
-  local: () => () => import("./chunk-H3K4GA2P.mjs"),
-  install: () => () => import("./chunk-5PUQT3YS.mjs"),
+  mcp: () => () => import("./chunk-ARIDZOTI.mjs"),
+  watch: () => () => import("./chunk-CHC4VZF5.mjs"),
+  local: () => () => import("./chunk-WPNMWNCL.mjs"),
+  install: () => () => import("./chunk-CKLCR5G4.mjs"),
+  wake: () => () => import("./chunk-6SUV3EW6.mjs"),
   hook: (name) => Object.hasOwn(hooks, name) ? hooks[name] : void 0
 });