@iowarp/clio-coder 0.3.0

package/dist/chunk-4UQA7NCT.js

@@ -0,0 +1,29 @@
+import {
+  GUARDRAIL_ENV_VARS,
+  resolveGuardrail
+} from "./chunk-UHTSULZS.js";
+
+// src/cli/internal-dispatch.ts
+function armInternalDispatchDeadline(dispatch, runId, label, env = process.env, maxTimeoutMs) {
+  const configuredTimeoutMs = resolveGuardrail("internalDispatchTimeoutMs", env);
+  const timeoutMs = maxTimeoutMs === void 0 ? configuredTimeoutMs : Math.min(configuredTimeoutMs, Math.max(1, maxTimeoutMs));
+  const productCapped = timeoutMs < configuredTimeoutMs;
+  let fired = false;
+  const timer = setTimeout(() => {
+    fired = true;
+    try {
+      dispatch.abort(runId, { cause: "timeout", detail: `${label} timed out after ${timeoutMs}ms` });
+    } catch {
+    }
+  }, timeoutMs);
+  return {
+    timedOut: () => fired,
+    clear: () => clearTimeout(timer),
+    message: () => productCapped ? `${label} exceeded its ${Math.round(timeoutMs / 1e3)}s latency ceiling and was aborted.` : `${label} timed out after ${Math.round(timeoutMs / 1e3)}s and was aborted. Raise guardrails.internalDispatchTimeoutMs (env ${GUARDRAIL_ENV_VARS.internalDispatchTimeoutMs}) for slower targets.`
+  };
+}
+
+export {
+  armInternalDispatchDeadline
+};
+//# sourceMappingURL=chunk-4UQA7NCT.js.map

package/dist/chunk-527KG6XR.js

@@ -0,0 +1,497 @@
+import {
+  readLayeredSettings
+} from "./chunk-UU3R62TT.js";
+import {
+  BusChannels,
+  getSharedBus
+} from "./chunk-D5YD55AR.js";
+import {
+  formatSettingsFailure,
+  readSettings,
+  settingsPath,
+  updateSettings
+} from "./chunk-JWHCJDCI.js";
+
+// src/core/termination.ts
+var DEFAULT_SHUTDOWN_HOOK_MS = 500;
+var SIGNAL_EXIT_CODES = {
+  SIGHUP: 129,
+  SIGINT: 130,
+  SIGTERM: 143
+};
+function resolveShutdownHookBudgetMs() {
+  const raw = process.env.CLIO_CODER_SHUTDOWN_HOOK_MS;
+  if (raw === void 0) return DEFAULT_SHUTDOWN_HOOK_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) return DEFAULT_SHUTDOWN_HOOK_MS;
+  return parsed;
+}
+async function runWithBudget(op, budgetMs, onError) {
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), budgetMs);
+  });
+  try {
+    const done = Promise.resolve().then(() => op()).then(() => "done").catch((err) => {
+      onError?.(err);
+      return "done";
+    });
+    const outcome = await Promise.race([done, timeout]);
+    return outcome === "done";
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+var TerminationCoordinator = class {
+  phase = "idle";
+  drainHooks = [];
+  terminateHooks = [];
+  persistHooks = [];
+  exitCode = 0;
+  started = false;
+  signalHandler = null;
+  getPhase() {
+    return this.phase;
+  }
+  /**
+   * The process exit code this shutdown will use. Set before any hook runs,
+   * so a hook sealing terminal accounting records the same status the process
+   * reports (130 for SIGINT, 143 for SIGTERM).
+   */
+  getExitCode() {
+    return this.exitCode;
+  }
+  onDrain(hook) {
+    this.drainHooks.push(hook);
+  }
+  onTerminate(hook) {
+    this.terminateHooks.push(hook);
+  }
+  onPersist(hook) {
+    this.persistHooks.push(hook);
+  }
+  async shutdown(code = 0) {
+    if (this.started) return;
+    this.started = true;
+    this.exitCode = code;
+    const bus = getSharedBus();
+    const debug = process.env.CLIO_CODER_DEBUG_SHUTDOWN === "1";
+    const budgetMs = resolveShutdownHookBudgetMs();
+    const mark = debug ? process.hrtime.bigint() : 0n;
+    const log = (msg) => {
+      if (!debug) return;
+      const ms = Number(process.hrtime.bigint() - mark) / 1e6;
+      process.stderr.write(`[clio:shutdown] +${ms.toFixed(1)}ms ${msg}
+`);
+    };
+    this.phase = "draining";
+    bus.emit(BusChannels.ShutdownRequested, { phase: this.phase });
+    log("drain:start");
+    await this.runHooks(this.drainHooks, "drain", budgetMs, log);
+    log("drain:end");
+    bus.emit(BusChannels.ShutdownDrained, {});
+    this.phase = "terminating";
+    log("terminate:start");
+    await this.runHooks(this.terminateHooks, "terminate", budgetMs, log);
+    log("terminate:end");
+    bus.emit(BusChannels.ShutdownTerminated, {});
+    this.phase = "persisting";
+    log("persist:start");
+    await this.runHooks(this.persistHooks, "persist", budgetMs, log);
+    log("persist:end");
+    bus.emit(BusChannels.ShutdownPersisted, {});
+    this.phase = "exiting";
+    bus.emit(BusChannels.SessionEnd, { exitCode: this.exitCode });
+    log("process.exit");
+    process.exit(this.exitCode);
+  }
+  async runHooks(hooks, phase, budgetMs, log) {
+    for (let i = 0; i < hooks.length; i++) {
+      const hook = hooks[i];
+      if (!hook) continue;
+      const t0 = process.hrtime.bigint();
+      const completed = await runWithBudget(hook, budgetMs, (err) => {
+        console.error("[clio:termination] hook failed:", err);
+      });
+      const dt = Number(process.hrtime.bigint() - t0) / 1e6;
+      if (!completed) {
+        process.stderr.write(
+          `[clio:termination] ${phase}[${i}] exceeded ${budgetMs}ms budget; abandoning and continuing shutdown
+`
+        );
+      }
+      log(`  ${phase}[${i}] ${dt.toFixed(1)}ms${completed ? "" : " (timed out)"}`);
+    }
+  }
+  /**
+   * SIGHUP is here for the same reason as SIGTERM. Without a listener Node
+   * takes its default action and the process dies with no shutdown at all,
+   * which on a TUI session means the terminal is never given back. Exit codes
+   * follow the 128+signal convention.
+   */
+  installSignalHandlers() {
+    if (this.signalHandler) return;
+    const handler = (signal) => {
+      process.stderr.write(`
+Clio Coder: received ${signal}, shutting down...
+`);
+      void this.shutdown(SIGNAL_EXIT_CODES[signal] ?? 143);
+    };
+    this.signalHandler = handler;
+    process.once("SIGINT", handler);
+    process.once("SIGTERM", handler);
+    process.once("SIGHUP", handler);
+  }
+  /**
+   * Hand SIGINT to a foreground owner and return the call that takes it back.
+   *
+   * Boot arms this coordinator before any interactive surface exists, and Node
+   * runs signal listeners in registration order, so a TUI that merely added its
+   * own listener would lose every first press to a shutdown already underway.
+   * One owner holds the interrupt at a time and the transfer is explicit.
+   * SIGTERM is not part of the handover; it is never an interactive gesture.
+   */
+  releaseInterruptOwnership() {
+    const handler = this.signalHandler;
+    if (!handler) return () => {
+    };
+    process.off("SIGINT", handler);
+    let restored = false;
+    return () => {
+      if (restored) return;
+      restored = true;
+      process.once("SIGINT", handler);
+    };
+  }
+};
+var coordinator = null;
+function getTerminationCoordinator() {
+  if (!coordinator) coordinator = new TerminationCoordinator();
+  return coordinator;
+}
+
+// src/core/domain-loader.ts
+async function loadDomains(modules) {
+  const order = topoSort(modules);
+  const contracts = /* @__PURE__ */ new Map();
+  const extensions = /* @__PURE__ */ new Map();
+  const loaded = [];
+  const failed = [];
+  const bus = getSharedBus();
+  const context = {
+    bus,
+    getContract(dep) {
+      return contracts.get(dep);
+    }
+  };
+  for (const name of order) {
+    const mod = modules.find((m) => m.manifest.name === name);
+    if (!mod) continue;
+    try {
+      const bundle = await mod.createExtension(context);
+      await bundle.extension.start();
+      extensions.set(name, bundle.extension);
+      contracts.set(name, bundle.contract);
+      loaded.push(name);
+      bus.emit(BusChannels.DomainLoaded, { name });
+    } catch (error) {
+      failed.push({ name, error });
+      bus.emit(BusChannels.DomainFailed, { name, error });
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[clio:domain] load failed: ${name}: ${message}
+`);
+      throw new DomainLoadError(name, error);
+    }
+  }
+  const stop = async () => {
+    const debug = process.env.CLIO_CODER_DEBUG_SHUTDOWN === "1";
+    const budgetMs = resolveShutdownHookBudgetMs();
+    for (const name of [...loaded].reverse()) {
+      const ext = extensions.get(name);
+      if (!ext?.stop) continue;
+      const stopFn = ext.stop.bind(ext);
+      const t0 = debug ? process.hrtime.bigint() : 0n;
+      const completed = await runWithBudget(stopFn, budgetMs, (err) => {
+        console.error(`[clio:domain-loader] ${name}.stop() failed:`, err);
+      });
+      if (!completed) {
+        process.stderr.write(`[clio:domain-loader] ${name}.stop() exceeded ${budgetMs}ms budget; abandoning
+`);
+      }
+      if (debug) {
+        const dt = Number(process.hrtime.bigint() - t0) / 1e6;
+        process.stderr.write(`[clio:shutdown]   domain.${name} ${dt.toFixed(1)}ms${completed ? "" : " (timed out)"}
+`);
+      }
+    }
+  };
+  const getContract = (name) => {
+    return contracts.get(name);
+  };
+  return { loaded, failed, getContract, stop };
+}
+function topoSort(modules) {
+  const names = new Set(modules.map((m) => m.manifest.name));
+  const unresolved = [];
+  for (const m of modules) {
+    for (const dep of m.manifest.dependsOn) {
+      if (!names.has(dep)) unresolved.push(`${m.manifest.name} -> ${dep}`);
+    }
+  }
+  if (unresolved.length > 0) {
+    throw new DomainLoadError("topo", new Error(`Unresolved dependencies: ${unresolved.join(", ")}`));
+  }
+  const order = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (name) => {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      throw new DomainLoadError("topo", new Error(`Cycle detected at ${name}`));
+    }
+    visiting.add(name);
+    const mod = modules.find((m) => m.manifest.name === name);
+    if (mod) {
+      for (const dep of mod.manifest.dependsOn) visit(dep);
+    }
+    visiting.delete(name);
+    visited.add(name);
+    order.push(name);
+  };
+  for (const m of modules) visit(m.manifest.name);
+  return order;
+}
+var DomainLoadError = class extends Error {
+  constructor(domain, cause) {
+    super(`Domain '${domain}' failed to load: ${cause instanceof Error ? cause.message : String(cause)}`);
+    this.domain = domain;
+    this.cause = cause;
+    this.name = "DomainLoadError";
+  }
+  domain;
+  cause;
+};
+
+// src/domains/config/agent-namespace.ts
+function assertAgentIdNamespace(nativeRecipes, acpDelegates) {
+  const native = new Set(nativeRecipes.map((recipe) => recipe.id));
+  const collision = acpDelegates.find((delegate) => native.has(delegate.id));
+  if (collision !== void 0) {
+    throw new Error(
+      `agent id collision: native recipe '${collision.id}' and ACP delegation agent '${collision.id}' share one namespace`
+    );
+  }
+}
+
+// src/domains/config/classify.ts
+var HOT_RELOAD_FIELDS = /* @__PURE__ */ new Set(["theme", "keybindings", "autonomy", "modelSelector"]);
+var NEXT_TURN_FIELDS = /* @__PURE__ */ new Set([
+  "identity",
+  "targets",
+  "orchestrator.target",
+  "orchestrator.model",
+  "orchestrator.thinkingLevel",
+  "background.target",
+  "background.model",
+  "background.thinkingLevel",
+  "memory",
+  "workers.default.target",
+  "workers.default.model",
+  "workers.default.thinkingLevel",
+  "workers.profiles",
+  "workers.agentBindings",
+  "workers.maxRetries",
+  "workers.onPermission",
+  "fleet",
+  "routing",
+  "scope",
+  "budget.sessionCeilingUsd",
+  "defaults",
+  "terminal",
+  "skills",
+  "delegation",
+  "compaction",
+  "retry"
+]);
+var RESTART_REQUIRED_FIELDS = /* @__PURE__ */ new Set(["budget.concurrency", "runtimePlugins"]);
+function matchesPrefix(path, fields) {
+  if (fields.has(path)) return true;
+  for (const field of fields) {
+    if (path.startsWith(`${field}.`)) return true;
+  }
+  return false;
+}
+function diffSettings(prev, next) {
+  const changed = collectChangedPaths(prev, next);
+  const diff = { hotReload: [], nextTurn: [], restartRequired: [] };
+  for (const p of changed) {
+    if (matchesPrefix(p, HOT_RELOAD_FIELDS)) diff.hotReload.push(p);
+    else if (matchesPrefix(p, NEXT_TURN_FIELDS)) diff.nextTurn.push(p);
+    else if (matchesPrefix(p, RESTART_REQUIRED_FIELDS)) diff.restartRequired.push(p);
+    else {
+      diff.restartRequired.push(p);
+    }
+  }
+  return diff;
+}
+function collectChangedPaths(a, b, prefix = "") {
+  if (Object.is(a, b)) return [];
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) {
+    return [prefix || "(root)"];
+  }
+  const keys = /* @__PURE__ */ new Set([...Object.keys(a), ...Object.keys(b)]);
+  const paths = [];
+  for (const k of keys) {
+    const nextPrefix = prefix ? `${prefix}.${k}` : k;
+    const av = a[k];
+    const bv = b[k];
+    paths.push(...collectChangedPaths(av, bv, nextPrefix));
+  }
+  return paths;
+}
+
+// src/domains/config/watcher.ts
+import { watch } from "node:fs";
+import { basename, dirname } from "node:path";
+function startConfigWatcher(cb) {
+  const path = settingsPath();
+  const settingsFile = basename(path);
+  let watcher = null;
+  let debounceTimer = null;
+  try {
+    watcher = watch(dirname(path), { persistent: false }, (_event, filename) => {
+      if (filename !== null && filename !== settingsFile) return;
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        cb({ at: Date.now() });
+      }, 80);
+    });
+  } catch (err) {
+    console.error("[clio:config] watcher setup failed:", err);
+  }
+  return {
+    stop() {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      watcher?.close();
+      watcher = null;
+    }
+  };
+}
+
+// src/domains/config/extension.ts
+function createConfigBundle(context) {
+  let watcher = null;
+  let snapshot = null;
+  let reloadFailure = null;
+  const listeners = /* @__PURE__ */ new Map([
+    ["hotReload", /* @__PURE__ */ new Set()],
+    ["nextTurn", /* @__PURE__ */ new Set()],
+    ["restartRequired", /* @__PURE__ */ new Set()]
+  ]);
+  function assertAgentNamespace(settings) {
+    const agents = context.getContract("agents");
+    if (agents) assertAgentIdNamespace(agents.list(), settings.delegation.agents);
+  }
+  function dispatch(kind, payload) {
+    const bus = context.bus;
+    const channel = kind === "hotReload" ? BusChannels.ConfigHotReload : kind === "nextTurn" ? BusChannels.ConfigNextTurn : BusChannels.ConfigRestartRequired;
+    bus.emit(channel, payload);
+    for (const listener of listeners.get(kind) ?? []) {
+      try {
+        listener(payload);
+      } catch (err) {
+        console.error(`[clio:config] listener for ${kind} threw:`, err);
+      }
+    }
+  }
+  function publishReloadFailure(message) {
+    if (reloadFailure === message) return;
+    reloadFailure = message;
+    context.bus.emit(BusChannels.ConfigReloadFailed, { message });
+  }
+  function onWatcherFire() {
+    let next;
+    try {
+      readSettings();
+      next = readLayeredSettings(process.cwd()).settings;
+    } catch (err) {
+      publishReloadFailure(formatSettingsFailure(err));
+      return;
+    }
+    const prev = snapshot;
+    try {
+      assertAgentNamespace(next);
+    } catch (err) {
+      publishReloadFailure(formatSettingsFailure(err));
+      return;
+    }
+    publishReloadFailure(null);
+    snapshot = next;
+    if (!prev) return;
+    const diff = diffSettings(prev, next);
+    if (diff.hotReload.length > 0) dispatch("hotReload", { diff, settings: next });
+    if (diff.nextTurn.length > 0) dispatch("nextTurn", { diff, settings: next });
+    if (diff.restartRequired.length > 0) dispatch("restartRequired", { diff, settings: next });
+  }
+  const extension = {
+    async start() {
+      readSettings();
+      snapshot = readLayeredSettings(process.cwd()).settings;
+      watcher = startConfigWatcher(() => onWatcherFire());
+    },
+    async stop() {
+      watcher?.stop();
+      watcher = null;
+    }
+  };
+  const contract = {
+    get() {
+      if (!snapshot) throw new Error("config domain not started");
+      return snapshot;
+    },
+    set(next) {
+      contract.update?.(() => next);
+    },
+    update(mutate) {
+      if (!snapshot) throw new Error("config domain not started");
+      const previous = snapshot;
+      const candidate = structuredClone(previous);
+      mutate(candidate);
+      assertAgentNamespace(candidate);
+      updateSettings(mutate);
+      const normalized = readLayeredSettings(process.cwd()).settings;
+      snapshot = normalized;
+      const diff = diffSettings(previous, normalized);
+      if (diff.hotReload.length > 0) dispatch("hotReload", { diff, settings: normalized });
+      if (diff.nextTurn.length > 0) dispatch("nextTurn", { diff, settings: normalized });
+      if (diff.restartRequired.length > 0) dispatch("restartRequired", { diff, settings: normalized });
+    },
+    onChange(kind, listener) {
+      listeners.get(kind)?.add(listener);
+      return () => {
+        listeners.get(kind)?.delete(listener);
+      };
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/config/manifest.ts
+var ConfigManifest = {
+  name: "config",
+  dependsOn: []
+};
+
+// src/domains/config/index.ts
+var ConfigDomainModule = {
+  manifest: ConfigManifest,
+  createExtension: createConfigBundle
+};
+
+export {
+  getTerminationCoordinator,
+  loadDomains,
+  assertAgentIdNamespace,
+  ConfigDomainModule
+};
+//# sourceMappingURL=chunk-527KG6XR.js.map