khala-cli 0.4.9 → 0.4.10

package/dist/chunk-W6HM6F2U.mjs

@@ -0,0 +1,901 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  adapterFor
+} from "./chunk-5JSGA6OB.mjs";
+import {
+  installedLauncher,
+  launcherShellQuote,
+  readWakeSettings
+} from "./chunk-2AMWQ7RB.mjs";
+import {
+  HARNESS_REGISTRY,
+  filesForDir,
+  readStateFile,
+  stateRoot
+} from "./chunk-PN25BUQ4.mjs";
+import {
+  readWakeState
+} from "./chunk-ZSKLNZWZ.mjs";
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
+
+// src/wake/status.ts
+init_define_KHALA_BUNDLE();
+import path3 from "node:path";
+
+// src/wake/installation.ts
+init_define_KHALA_BUNDLE();
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/index.js
+init_define_KHALA_BUNDLE();
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/parse.js
+init_define_KHALA_BUNDLE();
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/struct.js
+init_define_KHALA_BUNDLE();
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/primitive.js
+init_define_KHALA_BUNDLE();
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/date.js
+init_define_KHALA_BUNDLE();
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/error.js
+init_define_KHALA_BUNDLE();
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/util.js
+init_define_KHALA_BUNDLE();
+function indexOfNewline(str, start = 0) {
+  let idx = str.indexOf("\n", start);
+  if (str.charCodeAt(idx - 1) === 13)
+    idx--;
+  return idx;
+}
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
+  }
+}
+function skipUntil(ctx, sep, end) {
+  let ptr = ctx.p;
+  if (!end) {
+    ptr = indexOfNewline(ctx.s, ptr);
+    ctx.p = ptr < 0 ? ctx.s.length : ptr;
+    return;
+  }
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 35) {
+      skipComment(ctx);
+    } else if (c === end || c === sep) {
+      return;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: ctx.s,
+    ptr
+  });
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+function parseString(ctx) {
+  let start = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
+  let first = c;
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
+  if (isMultiline) {
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
+  }
+  let parsed = "";
+  let sliceStart = ctx.p;
+  let state = 0;
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
+      state = state && 3;
+    } else if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
+      if (isMultiline) {
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+      }
+      if (!state)
+        parsed += ctx.s.slice(sliceStart, ctx.p);
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
+    } else if (!state) {
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === 120 || c === 117 || c === 85) {
+        let value = 0;
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0; j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p + 1);
+          let digit = (
+            /* 0-9 */
+            hex >= 48 && hex <= 57 ? hex - 48 : (
+              /* A-F */
+              hex >= 65 && hex <= 70 ? hex - 65 + 10 : (
+                /* a-f */
+                hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1
+              )
+            )
+          );
+          if (digit < 0)
+            throw new TomlError("invalid non-hex character in unicode escape", { toml: ctx.s, ptr: ctx.p + 1 });
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          throw new TomlError("invalid unicode escape", { toml: ctx.s, ptr: ctx.p });
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = ctx.p + 1;
+        state = 0;
+      } else if (c === 32 || c === 9) {
+        state = 2;
+      } else {
+        if (c === 98)
+          parsed += "\b";
+        else if (c === 116)
+          parsed += "	";
+        else if (c === 110)
+          parsed += "\n";
+        else if (c === 102)
+          parsed += "\f";
+        else if (c === 114)
+          parsed += "\r";
+        else if (c === 101)
+          parsed += "\x1B";
+        else if (c === 34)
+          parsed += '"';
+        else if (c === 92)
+          parsed += "\\";
+        else
+          throw new TomlError("unrecognized escape sequence", { toml: ctx.s, ptr: ctx.p });
+        sliceStart = ctx.p + 1;
+        state = 0;
+      }
+    } else if (c !== 32 && c !== 9) {
+      if (state === 2) {
+        throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+          toml: ctx.s,
+          ptr: sliceStart
+        });
+      }
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
+    }
+  }
+  throw new TomlError("unfinished string", { toml: ctx.s, ptr: start });
+}
+function sliceAndTrimEndOf(ctx, start, end) {
+  let value = ctx.s.slice(start, end);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > 0) {
+    skipComment({ s: value, p: commentIdx, d: 0 });
+    value = value.slice(0, commentIdx);
+  }
+  return value.trimEnd();
+}
+function parseValue(ctx, integersAsBigInt, end) {
+  let ptr = ctx.p;
+  let err = { toml: ctx.s, ptr };
+  skipUntil(ctx, 44, end);
+  let value = sliceAndTrimEndOf(ctx, ptr, ctx.p);
+  if (!value)
+    throw new TomlError("incomplete declaration: value expected", err);
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", err);
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", err);
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", err);
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid())
+    throw new TomlError("invalid value", err);
+  return date;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/extract.js
+init_define_KHALA_BUNDLE();
+function extractValue(ctx, end, integersAsBigInt) {
+  let ptr = ctx.p;
+  let c = ctx.s.charCodeAt(ptr);
+  if (c === 91 || c === 123) {
+    if (!ctx.d--) {
+      throw new TomlError("document contains excessively nested structures. aborting.", {
+        toml: ctx.s,
+        ptr
+      });
+    }
+    let value = c === 91 ? parseArray(ctx, integersAsBigInt) : parseInlineTable(ctx, integersAsBigInt);
+    ctx.d++;
+    return value;
+  }
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
+  }
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return true;
+  }
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return false;
+  }
+  return parseValue(ctx, integersAsBigInt, end);
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(ctx, end = "=") {
+  let start = ctx.p;
+  let dot = start - 1;
+  let parsed = [];
+  let endPtr = ctx.s.indexOf(end, start);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: ctx.s,
+      ptr: start
+    });
+  }
+  do {
+    let c = ctx.s.charCodeAt(ctx.p = ++dot);
+    if (c !== 32 && c !== 9) {
+      if (c === 34 || c === 39) {
+        if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2)) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        let part = parseString(ctx);
+        dot = ctx.s.indexOf(".", ctx.p);
+        let strEnd = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: ctx.s,
+            ptr: newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        if (endPtr < ctx.p) {
+          endPtr = ctx.s.indexOf(end, ctx.p);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: ctx.s,
+              ptr: start
+            });
+          }
+        }
+        parsed.push(part);
+      } else {
+        dot = ctx.s.indexOf(".", ctx.p);
+        let part = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: ctx.s,
+            ptr: ctx.p
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  ctx.p = endPtr + 1;
+  skipVoid(ctx, true, true);
+  return parsed;
+}
+function parseInlineTable(ctx, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let p = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0; i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = {};
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: ctx.s,
+          ptr: p
+        });
+      }
+      if (!hasOwn && k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (hasOwn) {
+      throw new TomlError("trying to redefine an already defined value", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+    let value = extractValue(ctx, 125, integersAsBigInt);
+    seen.add(t[k] = value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
+  }
+  throw new TomlError("unfinished table encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
+}
+function parseArray(ctx, integersAsBigInt) {
+  let res = [];
+  let c;
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(ctx, 93, integersAsBigInt));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
+  }
+  throw new TomlError("unfinished array encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let ctx = { s: toml, p: 0, d: maxDepth };
+  let res = {};
+  let meta = {};
+  let tmp;
+  let tbl = res;
+  let m = meta;
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      let k = parseKey(ctx, "]");
+      if (isTableArray) {
+        if (toml.charCodeAt(ctx.p - 1) !== 93) {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: ctx.p - 1
+          });
+        }
+        ctx.p++;
+      }
+      let p = peekTable(
+        k,
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+    } else {
+      tmp = ctx.p;
+      let k = parseKey(ctx);
+      let p = peekTable(
+        k,
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr: tmp
+        });
+      }
+      p[1][p[0]] = extractValue(ctx, void 0, integersAsBigInt);
+    }
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && tmp !== 13) {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr: ctx.p
+      });
+    }
+    skipVoid(ctx);
+  }
+  return res;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.8.0/node_modules/smol-toml/dist/stringify.js
+init_define_KHALA_BUNDLE();
+
+// src/wake/installation.ts
+var object = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+async function text(file) {
+  try {
+    return await readFile(file, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function nativeWakeInstallation(harness, env) {
+  const home = env.HOME ?? os.homedir();
+  if (harness === "codex") {
+    const dir = env.CODEX_HOME && path.isAbsolute(env.CODEX_HOME) ? env.CODEX_HOME : path.join(home, ".codex");
+    try {
+      const config = parse(await text(path.join(dir, "config.toml")) ?? "");
+      const servers = config.mcp_servers;
+      const entry = object(servers) ? servers.khala : void 0;
+      if (object(entry) && entry.enabled !== false && typeof entry.command === "string" && Array.isArray(entry.args) && entry.args.includes("mcp") && entry.args.indexOf("--harness") >= 0 && entry.args[entry.args.indexOf("--harness") + 1] === "codex") return;
+    } catch {
+    }
+    try {
+      const config = JSON.parse(await text(path.join(dir, "hooks.json")) ?? "{}");
+      if (object(config) && object(config.hooks) && Object.values(config.hooks).some((groups) => Array.isArray(groups) && groups.some((group) => object(group) && Array.isArray(group.hooks) && group.hooks.some((hook) => object(hook) && typeof hook.command === "string" && /\bkhala(?:[.]cmd)?["']?\s+hook\s+deliver\s+--harness\s+codex\b/u.test(hook.command))))) return;
+    } catch {
+    }
+  } else if (harness === "opencode") {
+    const dir = path.join(env.XDG_CONFIG_HOME && path.isAbsolute(env.XDG_CONFIG_HOME) ? env.XDG_CONFIG_HOME : path.join(home, ".config"), "opencode");
+    const marker = (await text(path.join(dir, "opencode.json.khala-plugin")))?.trim();
+    for (const file of ["opencode.jsonc", "opencode.json"]) {
+      try {
+        const config = JSON.parse((await text(path.join(dir, file)) ?? "{}").replace(/^\uFEFF/u, ""));
+        if (!object(config)) continue;
+        if (Array.isArray(config.plugin) && config.plugin.some((spec) => typeof spec === "string" && (spec === "khala-opencode" || spec.startsWith("khala-opencode@") || spec === marker || /^file:.*[/\\]khala-opencode-[^/\\]+\.tgz$/u.test(spec)))) return;
+        if (object(config.mcp) && object(config.mcp.khala) && config.mcp.khala.enabled !== false)
+          return "OpenCode has only the Khala MCP entry; native wake requires the Khala plugin.";
+      } catch {
+      }
+    }
+  } else return;
+  return `Khala is not installed for ${harness}; run khala install ${harness}.`;
+}
+
+// src/wake/antigravity-registration.ts
+init_define_KHALA_BUNDLE();
+import os2 from "node:os";
+import path2 from "node:path";
+function antigravityRegisterCommand(env = process.env, bin) {
+  const platform = process.platform;
+  const home = platform === "win32" ? env.USERPROFILE || os2.homedir() : env.HOME || os2.homedir();
+  return launcherShellQuote(platform, bin ?? installedLauncher(platform, platform === "win32" ? path2.win32 : path2.posix, home, env).bin) + " wake register --harness antigravity";
+}
+function antigravityRegisterHint(env = process.env, bin) {
+  return `Run ${antigravityRegisterCommand(env, bin)} through your own shell tool after khala_join and at every session start; repeat if the local server restarts. Never print or send the credential environment variables.`;
+}
+
+// src/wake/status.ts
+var CODEX_DAEMON_WAKE_NOTE = "Codex threads can keep answering mentions while the app-server daemon runs, even after the TUI exits. Stop with khala_leave, khala wake off --harness codex, or codex app-server daemon stop.";
+var WAKE_STATES = {
+  held: { reason: "Held by your Qwen setting.", remedy: "/peers accept, or change agents.crossSessionInbound in Qwen settings." },
+  active: { reason: "Idle wake is on.", remedy: "" },
+  needs_consent: { reason: "Idle wake needs consent.", remedy: "khala wake on --driver <d>" },
+  unavailable: { reason: "No remote-control API is available.", remedy: "", reasons: {
+    wake_status_unavailable: "Wake status is unavailable.",
+    antigravity_credentials_missing: "Antigravity native wake credentials are missing.",
+    antigravity_credentials_rejected: "Antigravity native wake credentials were rejected.",
+    qwen_session_missing: "Run wake status inside a Qwen session; its messaging socket is not inherited here.",
+    qwen_socket_missing: "Qwen session registry or private controller credential is unavailable.",
+    qwen_watcher_missing: "The Qwen background shell watcher is not armed; call khala_status inside Qwen for its installed run_shell_command command.",
+    qwen_refused: "Qwen cross-session messaging is refused or off.",
+    queue_missing: "Codex queue is missing.",
+    codex_binary_missing: "Codex queue is missing.",
+    codex_queue_unavailable: "Codex queue is unavailable.",
+    nonce_timeout: "The wake verification deadline passed.",
+    windows: "Windows has no supported remote-control API.",
+    driver_missing: "No wake driver is installed for this transport.",
+    monitor_missing: "The Muse monitor is not armed; start monitor on khala watch with persistent: true, wake_delay_ms: 0, show_lines: true.",
+    watcher_missing: "The Claude watcher is not armed.",
+    terminal_aborted: "The terminal wake check was cancelled.",
+    terminal_unavailable_on_platform: "This platform has no supported terminal remote-control API.",
+    terminal_empty_prompt_unavailable: "This harness has no verified empty-prompt pattern.",
+    terminal_consent_required: "Terminal wake needs consent; run khala wake on --driver terminal.",
+    terminal_capture_pending_prompt: "Terminal capture is pending; send the first Codex prompt.",
+    "no remote-control API": "No terminal remote-control API is available.",
+    terminal_not_idle: "The agent must be idle for at least 30 seconds before a terminal wake.",
+    terminal_agent_exited: "The captured agent process has exited or changed.",
+    terminal_pane_unsafe: "The terminal pane is unavailable or its input mode is unsafe.",
+    terminal_pane_not_owned: "The agent does not own the terminal pane foreground process group.",
+    terminal_prompt_not_empty: "The terminal prompt contains a draft or its cursor has moved.",
+    terminal_probe_failed: "The terminal remote-control check failed.",
+    wezterm_pane_missing: "The captured WezTerm pane is no longer available.",
+    wezterm_tty_unavailable: "WezTerm did not report the pane terminal device; ownership cannot be verified.",
+    wezterm_cursor_unavailable: "WezTerm did not report the cursor position; an empty prompt cannot be verified."
+  } },
+  disabled: { reason: "Idle wake is off.", remedy: "khala wake on --driver <d>" },
+  disabled_after_failures: { reason: "Idle wake was disabled after two unverified wakes.", remedy: "khala wake on --driver <d>" },
+  lapsed: { reason: "The Claude watcher passed its deadline; any prompt re-arms it.", remedy: "Send any prompt to re-arm the watcher." },
+  none_by_design: { reason: "The generic tier has no idle wake by design.", remedy: "" }
+};
+function wakeStatusText(driver, state, unavailableReason) {
+  const text2 = WAKE_STATES[state];
+  return { driver, state, reason: state === "unavailable" && unavailableReason ? WAKE_STATES.unavailable.reasons[unavailableReason] : text2.reason, ...text2.remedy ? { remedy: text2.remedy.replace("<d>", driver) } : {} };
+}
+function wakeDrivers(harness) {
+  const adapter = adapterFor(harness);
+  const drivers = (adapter?.wakeLadder ?? []).map((driver) => ({ ...driver, runtime: driver }));
+  for (const driver of adapter?.wakeConsentDrivers ?? []) if (!drivers.some((item) => item.id === driver.id)) drivers.push(driver);
+  if (harness === "claude" && !drivers.some((driver) => driver.id === "watcher")) drivers.unshift({ id: "watcher", rung: 2, optIn: false });
+  return drivers.sort((a, b) => a.rung - b.rung);
+}
+function watcherAlive(pid) {
+  if (typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function wakeStatus(harness, options = {}) {
+  const env = options.env ?? process.env;
+  const settings = await readWakeSettings(stateRoot(env));
+  const states = options.files ? await readWakeState(options.files.dir) : {};
+  const drivers = wakeDrivers(harness);
+  if (!drivers.length) return [{ harness, rung: 0, ...wakeStatusText("none", harness === "generic" ? "none_by_design" : "unavailable", harness === "generic" ? void 0 : "driver_missing") }];
+  const rows = [];
+  for (const driver of drivers) {
+    const key = `${harness}/${driver.id}`;
+    let state;
+    let unavailableReason;
+    if (!Object.hasOwn(settings.off, key) && !states[driver.id]?.disabled && (harness === "codex" && driver.id === "queue" || harness === "opencode" && driver.id === "opencode-native")) {
+      const reason = await nativeWakeInstallation(harness, env);
+      if (reason) {
+        rows.push({ harness, rung: driver.rung, driver: driver.id, state: "unavailable", reason, remedy: `khala install ${harness}` });
+        continue;
+      }
+    }
+    if (Object.hasOwn(settings.off, key)) state = "disabled";
+    else if (states[driver.id]?.disabled) state = "disabled_after_failures";
+    else if (driver.optIn && !Object.hasOwn(settings.consent, key)) state = "needs_consent";
+    else if (driver.id === "watcher") {
+      const watcher = options.files ? await readStateFile(options.files.dir, "watcher.json") : null;
+      state = watcher?.state === "expired" ? "lapsed" : watcher?.state === "armed" && watcherAlive(watcher.pid) ? "active" : "unavailable";
+      if (state === "unavailable") unavailableReason = "watcher_missing";
+    } else if (driver.runtime) {
+      const files = options.files ?? filesForDir(path3.join(stateRoot(env), harness, "status"));
+      const ctx = { files, harness, sessionId: options.sessionId ?? "status", env, signal: new AbortController().signal, now: Date.now() };
+      const available = await driver.runtime.available(ctx);
+      state = available ? "active" : "unavailable";
+      if (!available) {
+        const reason = await driver.runtime.unavailableReason?.(ctx);
+        if (reason === "qwen_held") state = "held";
+        if (reason && Object.hasOwn(WAKE_STATES.unavailable.reasons, reason)) unavailableReason = reason;
+      }
+    } else {
+      state = "unavailable";
+      unavailableReason = process.platform === "win32" && driver.id === "terminal" ? "windows" : "driver_missing";
+    }
+    const status = wakeStatusText(driver.id, state, unavailableReason);
+    if (harness === "antigravity" && driver.id === "antigravity-native") {
+      if (!options.sessionId && state === "unavailable") {
+        status.reason = "Antigravity native wake credentials are scoped to a conversation.";
+        status.note = "Credential availability is session-scoped; run this command inside the Antigravity agent shell.";
+      } else if (unavailableReason === "antigravity_credentials_missing" || unavailableReason === "antigravity_credentials_rejected") status.remedy = antigravityRegisterCommand(env) + " through the agent shell";
+    }
+    rows.push({
+      harness,
+      rung: driver.rung,
+      ...status,
+      ...harness === "antigravity" && driver.id === "antigravity-native" ? { note: (status.note ? status.note + " " : "") + "Native wake and Sync continuation use billed model turns." } : {},
+      ...harness === "codex" && driver.id === "queue" ? { note: CODEX_DAEMON_WAKE_NOTE } : {}
+    });
+  }
+  return rows;
+}
+function selectedWakeStatus(rows) {
+  const row = rows.find((item) => item.state === "active") ?? rows[0];
+  const { driver, state, reason, remedy, note } = row;
+  return { driver, state, reason, ...remedy ? { remedy } : {}, ...note ? { note } : {} };
+}
+var WAKE_HARNESSES = HARNESS_REGISTRY.map((row) => row.id);
+async function wakeDisableNotice(dir) {
+  const { takeWakeDisableNotices } = await import("./chunk-FJVVSKZ3.mjs");
+  let drivers;
+  try {
+    const states = await readWakeState(dir);
+    if (!Object.values(states).some((state) => state.disabled && !state.noticeShown)) return void 0;
+    drivers = await takeWakeDisableNotices(dir);
+  } catch {
+    return void 0;
+  }
+  return drivers.length ? drivers.map((driver) => {
+    const status = wakeStatusText(driver, "disabled_after_failures");
+    return `Idle wake (${driver}): ${status.reason} Run \`${status.remedy}\` to re-enable it.`;
+  }).join("\n") : void 0;
+}
+
+export {
+  antigravityRegisterHint,
+  wakeStatusText,
+  wakeDrivers,
+  wakeStatus,
+  selectedWakeStatus,
+  WAKE_HARNESSES,
+  wakeDisableNotice
+};