khala-cli 0.4.1 → 0.4.4

package/dist/{chunk-3SWCRLWX.mjs → chunk-OS2JLDL7.mjs}

@@ -1,18 +1,8 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
-  KhalaClientError,
-  checkName,
-  readHumanColorId,
-  readHumanInitials
-} from "./chunk-AVJKIJ34.mjs";
-import {
-  StateError,
-  ensureStateDir,
-  readJson,
-  stateRoot
-} from "./chunk-B5BFL7OD.mjs";
+  LISTENING_MODES
+} from "./chunk-AUJEUKVM.mjs";
 import {
-  LISTENING_MODES,
   M1_LABEL_MAX_BYTES,
   array,
   decodeWith,
@@ -27,15 +17,86 @@ import {
   readHttpUrl,
   readMatrixUserId,
   readRoomId,
+  reserved,
   safeInteger,
   text,
   utcTimestamp,
   utf8Length,
   version
-} from "./chunk-N6LMHR7P.mjs";
-import {
-  bundle
-} from "./chunk-HAD5ZILW.mjs";
+} from "./chunk-SN3STAO2.mjs";
+
+// src/client.ts
+var KhalaClientError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message ?? code);
+    this.name = "KhalaClientError";
+    this.code = code;
+  }
+};
+
+// ../contracts/src/m1/colors.ts
+var HUMAN_COLOR_IDS = ["red", "orange", "amber", "lime", "green", "teal", "blue", "indigo", "purple", "pink"];
+function isHumanColorId(value) {
+  return typeof value === "string" && HUMAN_COLOR_IDS.includes(value);
+}
+function fnv1a(value) {
+  let hash = 2166136261;
+  for (const byte of new TextEncoder().encode(value)) {
+    hash ^= byte;
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash >>> 0;
+}
+function defaultHumanColor(ownerId) {
+  return HUMAN_COLOR_IDS[fnv1a(ownerId) % HUMAN_COLOR_IDS.length];
+}
+function readHumanColorId(input, path) {
+  if (!isHumanColorId(input)) return fail(path, "invalid_value");
+  return input;
+}
+
+// ../contracts/src/m1/initials.ts
+function normalizeInitials(input) {
+  if (typeof input !== "string") return null;
+  const nfc = input.normalize("NFC");
+  if ([...nfc].length !== 2) return null;
+  const up = nfc.toLocaleUpperCase("en-US");
+  return /^[\p{L}\p{Nd}]{2}$/u.test(up) ? up : null;
+}
+function isCanonicalInitials(value) {
+  return typeof value === "string" && normalizeInitials(value) === value;
+}
+function readHumanInitials(input, path) {
+  if (!isCanonicalInitials(input)) return fail(path, "invalid_value");
+  return input;
+}
+
+// ../contracts/src/m1/names.ts
+var USERNAME_MIN = 2;
+var USERNAME_MAX = 24;
+var AGENT_NAME_MIN = 2;
+var AGENT_NAME_MAX = 40;
+var mentionName = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/u;
+var adjacentSeparators = /[._-]{2}/u;
+var agentSuffix = /-(?:claude|codex|cursor)(?:-\d+)?$/iu;
+function checkName(input, kind) {
+  if (typeof input !== "string") return { ok: false, error: "invalid_characters" };
+  const name = input.trim();
+  if (name.length < (kind === "username" ? USERNAME_MIN : AGENT_NAME_MIN)) return { ok: false, error: "too_short" };
+  if (name.length > (kind === "username" ? USERNAME_MAX : AGENT_NAME_MAX)) return { ok: false, error: "too_long" };
+  if (!mentionName.test(name) || adjacentSeparators.test(name)) return { ok: false, error: "invalid_characters" };
+  if (reserved.test(name) || kind === "username" && agentSuffix.test(name)) return { ok: false, error: "reserved" };
+  return { ok: true, name };
+}
+var MODEL_NAMES = { claude: "Claude", codex: "Codex", cursor: "Cursor" };
+function defaultAgentName(username, harness, n = 1) {
+  return `${username}-${MODEL_NAMES[harness]}${n === 1 ? "" : `-${n}`}`;
+}
+function isDefaultAgentName(name, username, harness) {
+  const escaped = `${username}-${MODEL_NAMES[harness]}`.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+  return new RegExp(`^${escaped}(?:-\\d+)?$`, "iu").test(name);
+}
 
 // ../contracts/src/m1/local.ts
 var LOCAL_OWNER_USER_ID = "@khala_owner:local";
@@ -84,90 +145,90 @@ var localRoomKey = (roomId) => {
 var localRoomPath = (roomId, tail) => `/api/local/rooms/${encodeURIComponent(roomId)}/${tail}`;
 var LOCAL_OWNER_ID = "local-owner";
 var LOCAL_OWNER_DEVICE_ID = "KH_LOCAL_OWNER";
-function readLocalRoomId(input, path2) {
-  const value = readRoomId(input, path2);
-  if (!isLocalRoomId(value)) fail(path2, "invalid_value");
+function readLocalRoomId(input, path) {
+  const value = readRoomId(input, path);
+  if (!isLocalRoomId(value)) fail(path, "invalid_value");
   return value;
 }
-function readLocalUserId(input, path2) {
-  const value = readMatrixUserId(input, path2);
-  if (!isLocalUserId(value)) fail(path2, "invalid_value");
+function readLocalUserId(input, path) {
+  const value = readMatrixUserId(input, path);
+  if (!isLocalUserId(value)) fail(path, "invalid_value");
   return value;
 }
-function readLocalEventId(input, path2) {
-  const value = identifier(input, path2);
-  if (!isLocalEventId(value)) fail(path2, "invalid_value");
+function readLocalEventId(input, path) {
+  const value = identifier(input, path);
+  if (!isLocalEventId(value)) fail(path, "invalid_value");
   return value;
 }
-function readLocalTxnId(input, path2) {
-  const value = identifier(input, path2);
-  if (!isLocalTxnId(value)) fail(path2, "invalid_value");
+function readLocalTxnId(input, path) {
+  const value = identifier(input, path);
+  if (!isLocalTxnId(value)) fail(path, "invalid_value");
   return value;
 }
-function readLocalUsername(input, path2) {
-  const value = identifier(input, path2);
+function readLocalUsername(input, path) {
+  const value = identifier(input, path);
   const checked = checkName(value, "username");
-  if (!checked.ok || checked.name !== value) fail(path2, "invalid_value");
+  if (!checked.ok || checked.name !== value) fail(path, "invalid_value");
   return value;
 }
-function readLocalInitials(input, path2) {
-  return readHumanInitials(input, path2);
+function readLocalInitials(input, path) {
+  return readHumanInitials(input, path);
 }
-function record(input, path2, required, optional = []) {
+function record(input, path, required, optional = []) {
   const present = optional.filter((key) => typeof input === "object" && input !== null && Object.hasOwn(input, key));
-  return object(input, path2, [...required, ...present]);
+  return object(input, path, [...required, ...present]);
 }
 function has(input, key) {
   return typeof input === "object" && input !== null && Object.hasOwn(input, key);
 }
-function plainObject(input, path2) {
-  if (typeof input !== "object" || input === null || Array.isArray(input)) fail(path2, "not_object");
+function plainObject(input, path) {
+  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(path2, "not_object");
+  if (prototype !== Object.prototype && prototype !== null) fail(path, "not_object");
   return input;
 }
-function contentObject(input, path2) {
-  const value = plainObject(input, path2);
+function contentObject(input, path) {
+  const value = plainObject(input, path);
   let encoded;
   try {
     encoded = JSON.stringify(value);
   } catch {
-    fail(path2, "invalid_value");
+    fail(path, "invalid_value");
   }
-  if (utf8Length(encoded) > LOCAL_CONTENT_MAX_BYTES) fail(path2, "too_long");
+  if (utf8Length(encoded) > LOCAL_CONTENT_MAX_BYTES) fail(path, "too_long");
   return value;
 }
-function channelName(input, path2) {
-  const value = displayName(input, path2);
-  if ([...value].length > LOCAL_CHANNEL_NAME_MAX_CHARS) fail(path2, "too_long");
-  if (value !== value.trim()) fail(path2, "invalid_value");
+function channelName(input, path) {
+  const value = displayName(input, path);
+  if ([...value].length > LOCAL_CHANNEL_NAME_MAX_CHARS) fail(path, "too_long");
+  if (value !== value.trim()) fail(path, "invalid_value");
   return value;
 }
-function displayName(input, path2) {
-  const value = displayText(input, path2, M1_LABEL_MAX_BYTES);
-  if (value.length === 0) fail(path2, "empty");
+function displayName(input, path) {
+  const value = displayText(input, path, M1_LABEL_MAX_BYTES);
+  if (value.length === 0) fail(path, "empty");
   return value;
 }
-function seq(input, path2) {
-  const value = safeInteger(input, path2);
-  if (value === 0) fail(path2, "invalid_value");
+function seq(input, path) {
+  const value = safeInteger(input, path);
+  if (value === 0) fail(path, "invalid_value");
   return value;
 }
-function readCreateContent(input, path2) {
-  const r = record(input, path2, ["name", "createdBy"], ["operationId"]);
+function readCreateContent(input, path) {
+  const r = record(input, path, ["name", "createdBy"], ["operationId"]);
   return {
     name: channelName(r.field("name"), r.at("name")),
     createdBy: readLocalUserId(r.field("createdBy"), r.at("createdBy")),
     ...has(input, "operationId") ? { operationId: readLocalTxnId(r.field("operationId"), r.at("operationId")) } : {}
   };
 }
-function readNameContent(input, path2) {
-  const r = object(input, path2, ["name"]);
+function readNameContent(input, path) {
+  const r = object(input, path, ["name"]);
   return { name: channelName(r.field("name"), r.at("name")) };
 }
-function readMemberContent(input, path2) {
+function readMemberContent(input, path) {
   const modeKey = "com.khala.listening_mode";
-  const r = record(input, path2, ["user", "membership", "displayname", "kind"], ["harness", "invitedBy", modeKey]);
+  const r = record(input, path, ["user", "membership", "displayname", "kind"], ["harness", "invitedBy", modeKey]);
   const kind = literal(r.field("kind"), r.at("kind"), ["human", "agent"]);
   if (kind === "human") {
     for (const key of ["harness", modeKey]) if (has(input, key)) fail(r.at(key), "invalid_value");
@@ -189,28 +250,28 @@ function decodeLocalMemberContent(input) {
   return decodeWith(() => readMemberContent(input, ""));
 }
 var EVENT_TYPES = ["m.room.create", "m.room.name", "m.room.member", "m.room.message", "com.khala.event.v1", "com.khala.listening_mode.v1"];
-function readContent(input, path2, type) {
+function readContent(input, path, type) {
   switch (type) {
     case "m.room.create":
-      return readCreateContent(input, path2);
+      return readCreateContent(input, path);
     case "m.room.name":
-      return readNameContent(input, path2);
+      return readNameContent(input, path);
     case "m.room.member":
-      return readMemberContent(input, path2);
+      return readMemberContent(input, path);
     default: {
-      const content = contentObject(input, path2);
+      const content = contentObject(input, path);
       if (type === "m.room.message") {
-        literal(content["msgtype"], `${path2}.msgtype`, ["m.text", "m.notice"]);
-        const body = text(content["body"], `${path2}.body`, LOCAL_CONTENT_MAX_BYTES);
-        if (body.length === 0) fail(`${path2}.body`, "empty");
-        if (body.length > LOCAL_BODY_MAX_CHARS) fail(`${path2}.body`, "too_long");
+        literal(content["msgtype"], `${path}.msgtype`, ["m.text", "m.notice"]);
+        const body = text(content["body"], `${path}.body`, LOCAL_CONTENT_MAX_BYTES);
+        if (body.length === 0) fail(`${path}.body`, "empty");
+        if (body.length > LOCAL_BODY_MAX_CHARS) fail(`${path}.body`, "too_long");
       }
       return content;
     }
   }
 }
-function readEvent(input, path2) {
-  const r = record(input, path2, ["seq", "eventId", "roomId", "type", "sender", "ts", "content"], ["txnId", "previousContent"]);
+function readEvent(input, path) {
+  const r = record(input, path, ["seq", "eventId", "roomId", "type", "sender", "ts", "content"], ["txnId", "previousContent"]);
   const type = literal(r.field("type"), r.at("type"), EVENT_TYPES);
   return {
     seq: seq(r.field("seq"), r.at("seq")),
@@ -227,16 +288,16 @@ function readEvent(input, path2) {
 function decodeLocalEvent(input) {
   return decodeWith(() => readEvent(input, ""));
 }
-function limitedArray(input, path2, max, read) {
-  const values = array(input, path2);
-  if (values.length > max) fail(path2, "too_long");
-  return values.map((value, i) => read(value, elementPath(path2, i)));
+function limitedArray(input, path, max, read) {
+  const values = array(input, path);
+  if (values.length > max) fail(path, "too_long");
+  return values.map((value, i) => read(value, elementPath(path, i)));
 }
-function readEvents(input, path2, history) {
-  const events = limitedArray(input, path2, history ? LOCAL_HISTORY_LIMIT_MAX : LOCAL_EVENTS_PAGE_MAX, readEvent);
+function readEvents(input, path, history) {
+  const events = limitedArray(input, path, history ? LOCAL_HISTORY_LIMIT_MAX : LOCAL_EVENTS_PAGE_MAX, readEvent);
   events.forEach((event, i) => {
-    if (i > 0 && event.seq <= events[i - 1].seq) fail(`${elementPath(path2, i)}.seq`, "invalid_value");
-    if (history && event.type !== "m.room.message" && event.type !== "com.khala.event.v1") fail(`${elementPath(path2, i)}.type`, "invalid_value");
+    if (i > 0 && event.seq <= events[i - 1].seq) fail(`${elementPath(path, i)}.seq`, "invalid_value");
+    if (history && event.type !== "m.room.message" && event.type !== "com.khala.event.v1") fail(`${elementPath(path, i)}.type`, "invalid_value");
   });
   return events;
 }
@@ -258,8 +319,8 @@ function decodeLocalHistoryPage(input) {
     };
   });
 }
-function readLocalMe(input, path2) {
-  const r = record(input, path2, ["userId", "roomId", "roomName", "membership", "displayName"], ["invitedBy"]);
+function readLocalMe(input, path) {
+  const r = record(input, path, ["userId", "roomId", "roomName", "membership", "displayName"], ["invitedBy"]);
   return {
     userId: readLocalUserId(r.field("userId"), r.at("userId")),
     roomId: readLocalRoomId(r.field("roomId"), r.at("roomId")),
@@ -272,8 +333,8 @@ function readLocalMe(input, path2) {
 function decodeLocalMe(input) {
   return decodeWith(() => readLocalMe(input, ""));
 }
-function readLocalJoined(input, path2) {
-  const r = record(input, path2, ["seq", "ts"], []);
+function readLocalJoined(input, path) {
+  const r = record(input, path, ["seq", "ts"], []);
   return {
     seq: seq(r.field("seq"), r.at("seq")),
     ts: safeInteger(r.field("ts"), r.at("ts"))
@@ -282,8 +343,8 @@ function readLocalJoined(input, path2) {
 function decodeLocalJoined(input) {
   return decodeWith(() => readLocalJoined(input, ""));
 }
-function readLocalSendResult(input, path2) {
-  const r = record(input, path2, ["eventId"], []);
+function readLocalSendResult(input, path) {
+  const r = record(input, path, ["eventId"], []);
   return {
     eventId: readLocalEventId(r.field("eventId"), r.at("eventId"))
   };
@@ -291,8 +352,8 @@ function readLocalSendResult(input, path2) {
 function decodeLocalSendResult(input) {
   return decodeWith(() => readLocalSendResult(input, ""));
 }
-function readLocalErrorBody(input, path2) {
-  const r = record(input, path2, ["error"], []);
+function readLocalErrorBody(input, path) {
+  const r = record(input, path, ["error"], []);
   return {
     error: identifier(r.field("error"), r.at("error"))
   };
@@ -300,8 +361,8 @@ function readLocalErrorBody(input, path2) {
 function decodeLocalErrorBody(input) {
   return decodeWith(() => readLocalErrorBody(input, ""));
 }
-function readOwnerProfile(input, path2) {
-  const r = record(input, path2, ["v", "username", "color", "initials", "updatedAt"]);
+function readOwnerProfile(input, path) {
+  const r = record(input, path, ["v", "username", "color", "initials", "updatedAt"]);
   return {
     v: version(r.field("v"), r.at("v")),
     username: readLocalUsername(r.field("username"), r.at("username")),
@@ -313,11 +374,11 @@ function readOwnerProfile(input, path2) {
 function decodeOwnerProfile(input) {
   return decodeWith(() => readOwnerProfile(input, ""));
 }
-function nullableInitials(input, path2) {
-  return nullable(input, (value) => readLocalInitials(value, path2));
+function nullableInitials(input, path) {
+  return nullable(input, (value) => readLocalInitials(value, path));
 }
-function readMember(input, path2) {
-  const r = record(input, path2, ["userId", "participantId", "ownerId", "deviceId", "displayName", "kind", "membership"], ["harness", "ownerLabel", "listeningMode"]);
+function readMember(input, path) {
+  const r = record(input, path, ["userId", "participantId", "ownerId", "deviceId", "displayName", "kind", "membership"], ["harness", "ownerLabel", "listeningMode"]);
   const userId = readLocalUserId(r.field("userId"), r.at("userId"));
   const participantId = readLocalUserId(r.field("participantId"), r.at("participantId"));
   if (participantId !== userId) fail(r.at("participantId"), "invalid_value");
@@ -373,18 +434,18 @@ function decodeHelperFile(input) {
     };
   });
 }
-function readSha256(input, path2) {
-  const value = identifier(input, path2);
-  if (!/^[0-9a-f]{64}$/u.test(value)) fail(path2, "invalid_value");
+function readSha256(input, path) {
+  const value = identifier(input, path);
+  if (!/^[0-9a-f]{64}$/u.test(value)) fail(path, "invalid_value");
   return value;
 }
 function decodeChannelSecrets(input) {
   return decodeWith(() => {
     const r = object(input, "", ["v", "links", "members"]);
     const links = Object.fromEntries(Object.entries(plainObject(r.field("links"), r.at("links"))).map(([key, value]) => {
-      const path2 = `${r.at("links")}.${key}`;
-      readSha256(key, path2);
-      const link = record(value, path2, ["expiresAt", "kind"], ["consumedAt"]);
+      const path = `${r.at("links")}.${key}`;
+      readSha256(key, path);
+      const link = record(value, path, ["expiresAt", "kind"], ["consumedAt"]);
       return [key, {
         expiresAt: utcTimestamp(link.field("expiresAt"), link.at("expiresAt")),
         kind: literal(link.field("kind"), link.at("kind"), ["join"]),
@@ -392,9 +453,9 @@ function decodeChannelSecrets(input) {
       }];
     }));
     const members = Object.fromEntries(Object.entries(plainObject(r.field("members"), r.at("members"))).map(([key, value]) => {
-      const path2 = `${r.at("members")}.${key}`;
-      if (!isLocalAgentUserId(key)) fail(path2, "invalid_value");
-      const member = record(value, path2, ["tokenSha256"], ["sessionKey"]);
+      const path = `${r.at("members")}.${key}`;
+      if (!isLocalAgentUserId(key)) fail(path, "invalid_value");
+      const member = record(value, path, ["tokenSha256"], ["sessionKey"]);
       return [key, {
         tokenSha256: readSha256(member.field("tokenSha256"), member.at("tokenSha256")),
         ...has(value, "sessionKey") ? { sessionKey: readSha256(member.field("sessionKey"), member.at("sessionKey")) } : {}
@@ -404,131 +465,17 @@ function decodeChannelSecrets(input) {
   });
 }
 
-// src/local/lifecycle.ts
-import * as fs from "node:fs/promises";
-import { close as closeFd } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { setTimeout as sleepDefault } from "node:timers/promises";
-import { spawn as nodeSpawn } from "node:child_process";
-function helperPaths(env = process.env) {
-  const root = path.join(stateRoot(env), "local");
-  const candidate = /^\d{1,5}$/u.test(env.KHALA_LOCAL_PORT ?? "") ? Number(env.KHALA_LOCAL_PORT) : 0;
-  const port = candidate >= 1 && candidate <= 65535 ? candidate : LOCAL_DEFAULT_PORT;
-  return { root, helperFile: path.join(root, "helper.json"), logFile: path.join(root, "helper.log"), port, origin: `http://127.0.0.1:${port}` };
-}
-async function readHelperFile(env = process.env) {
-  const decoded = decodeHelperFile(await readJson(helperPaths(env).helperFile));
-  if (!decoded.ok) return null;
-  const file = decoded.value;
-  if (!Number.isSafeInteger(file.pid) || file.pid <= 0 || !Number.isSafeInteger(file.port) || file.port <= 0 || file.port > 65535 || file.origin !== `http://127.0.0.1:${file.port}` || !/^[A-Za-z0-9_-]{43}$/u.test(file.adminToken)) return null;
-  return file;
-}
-function helperBinPath() {
-  return fileURLToPath(bundle ? new URL("./khala.mjs", import.meta.url) : new URL("../../bin/khala.mjs", import.meta.url));
-}
-var HELPER_ENV_ALLOWLIST = [
-  "PATH",
-  "HOME",
-  "USER",
-  "LOGNAME",
-  "LANG",
-  "LC_ALL",
-  "TMPDIR",
-  "XDG_STATE_HOME",
-  "NODE_OPTIONS",
-  "KHALA_EGRESS_LOG",
-  "KHALA_LOCAL_PORT",
-  "KHALA_LOCAL_IDLE_MS",
-  "KHALA_LOCAL_WEB_DIR"
-];
-function helperChildEnv(env) {
-  const childEnv = {};
-  for (const key of HELPER_ENV_ALLOWLIST) if (env[key] !== void 0) childEnv[key] = env[key];
-  return childEnv;
-}
-var attempts = /* @__PURE__ */ new Map();
-async function healthy(fetchImpl, file) {
-  try {
-    const response = await fetchImpl(`${file.origin}/healthz`, { signal: AbortSignal.timeout(500) });
-    if (response.status !== 200) {
-      await response.body?.cancel();
-      return false;
-    }
-    const body = await response.json();
-    return typeof body === "object" && body !== null && "ok" in body && body.ok === true && "pid" in body && body.pid === file.pid;
-  } catch {
-    return false;
-  }
-}
-function connection(file) {
-  return { origin: file.origin, adminToken: file.adminToken };
-}
-async function attempt(env, deps) {
-  const fetchImpl = deps.fetch ?? globalThis.fetch;
-  const spawn = deps.spawn ?? ((command, argv, options) => nodeSpawn(command, [...argv], options));
-  const sleep = deps.sleep ?? sleepDefault;
-  const now = deps.now ?? Date.now;
-  const existing = await readHelperFile(env);
-  if (existing && await healthy(fetchImpl, existing)) return connection(existing);
-  const paths = helperPaths(env);
-  try {
-    await ensureStateDir(path.join(paths.root, "channels"));
-    let handle;
-    let fd;
-    let spawnFailed = false;
-    try {
-      if (deps.openLog) fd = await deps.openLog(paths.logFile);
-      else {
-        handle = await fs.open(paths.logFile, "a", 384);
-        await handle.chmod(384);
-        fd = handle.fd;
-      }
-      const child = spawn(process.execPath, [helperBinPath(), "local", "serve"], {
-        detached: true,
-        stdio: ["ignore", fd, fd],
-        env: helperChildEnv(env),
-        cwd: paths.root,
-        shell: false
-      });
-      child.on("error", () => {
-        spawnFailed = true;
-      });
-      child.unref();
-    } finally {
-      if (handle) await handle.close();
-      else if (fd !== void 0) {
-        const descriptor = fd;
-        await new Promise((resolve) => {
-          closeFd(descriptor, () => resolve());
-        });
-      }
-    }
-    const deadline = now() + 5e3;
-    while (!spawnFailed && now() < deadline) {
-      const file = await readHelperFile(env);
-      if (file && await healthy(fetchImpl, file) && !spawnFailed && now() <= deadline) return connection(file);
-      if (spawnFailed || now() >= deadline) break;
-      await sleep(100);
-    }
-  } catch (error) {
-    if (error instanceof StateError) throw error;
-  }
-  throw new KhalaClientError("internal_error", "helper_unavailable");
-}
-function ensureHelper(env = process.env, deps = {}) {
-  const key = helperPaths(env).helperFile;
-  const pending = attempts.get(key);
-  if (pending) return pending;
-  const promise = attempt(env, deps).finally(() => {
-    attempts.delete(key);
-  });
-  attempts.set(key, promise);
-  return promise;
-}
-
 export {
+  KhalaClientError,
+  isHumanColorId,
+  defaultHumanColor,
+  normalizeInitials,
+  checkName,
+  MODEL_NAMES,
+  defaultAgentName,
+  isDefaultAgentName,
   LOCAL_OWNER_USER_ID,
+  LOCAL_DEFAULT_PORT,
   LOCAL_LINK_TTL_MS,
   LOCAL_LONG_POLL_MAX_S,
   LOCAL_IDLE_EXIT_MS,
@@ -554,8 +501,6 @@ export {
   decodeLocalErrorBody,
   decodeOwnerProfile,
   decodeLocalMembersResponse,
-  decodeChannelSecrets,
-  helperPaths,
-  readHelperFile,
-  ensureHelper
+  decodeHelperFile,
+  decodeChannelSecrets
 };