khala-cli 0.4.8 → 0.4.9

package/dist/chunk-K7V7X6WU.mjs

@@ -0,0 +1,207 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-7R3EIDGR.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 (verified && input.verifiedAt !== void 0 && input.verifiedAt >= attempt.at && input.verifiedAt <= attempt.deadline) status = "success";
+      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;
+  });
+}
+
+export {
+  newNonce,
+  wakeLine,
+  withWakeLock,
+  readWakeState,
+  recordAttempt,
+  settleAttempts,
+  cancelAttempt,
+  failAttempt,
+  resetWakeDriver,
+  takeWakeDisableNotices
+};

package/dist/chunk-KMLXOPBQ.mjs

@@ -0,0 +1,20 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  cancelAttempt,
+  failAttempt,
+  readWakeState,
+  recordAttempt,
+  resetWakeDriver,
+  settleAttempts,
+  takeWakeDisableNotices
+} from "./chunk-K7V7X6WU.mjs";
+import "./chunk-7R3EIDGR.mjs";
+export {
+  cancelAttempt,
+  failAttempt,
+  readWakeState,
+  recordAttempt,
+  resetWakeDriver,
+  settleAttempts,
+  takeWakeDisableNotices
+};

package/dist/chunk-LBT47HLZ.mjs

@@ -0,0 +1,19 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  resolveHarness,
+  resolveSession,
+  resolveSessionId
+} from "./chunk-6BO3JSUP.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 {
+  resolveHarness,
+  resolveSession,
+  resolveSessionId
+};

package/dist/{chunk-IQJQ4RF5.mjs → chunk-NGSYOVQ4.mjs}

@@ -5,9 +5,19 @@ import {
   object,
   readMatrixUserId,
   version
-} from "./chunk-NKX3SLS7.mjs";
+} from "./chunk-NPSQNCOY.mjs";
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-7R3EIDGR.mjs";
+
+// ../contracts/src/m1/listening-mode.ts
+init_define_KHALA_BUNDLE();
+
+// ../contracts/src/delivery/listening-mode.ts
+init_define_KHALA_BUNDLE();
 
 // ../contracts/src/delivery/decode.ts
+init_define_KHALA_BUNDLE();
 var MAX_IDENTIFIER_BYTES = 512;
 var DecodeFailure = class extends Error {
   code;
@@ -67,6 +77,7 @@ function literal2(input, field, allowed) {
 }
 
 // ../contracts/src/delivery/ids.ts
+init_define_KHALA_BUNDLE();
 function readId(input, field) {
   return identifier(input, field);
 }