@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/chunk-J7CWMCQD.js

@@ -0,0 +1,255 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  gitCommitAttributionEnabled,
+  reportCommitAttributionDiagnostic,
+  withManagedGitCommitAttributionEnvironment
+} from "./chunk-COU2UHX6.js";
+import {
+  clampTimerDelayMs
+} from "./chunk-FQ4SKYE4.js";
+import {
+  AI_AGENT_NAME
+} from "./chunk-6EJMN2Y3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/headless-permission.ts
+init_esm_shims();
+var HEADLESS_PERMISSION_DENIED_REASON = "clio-coder run cannot confirm permission requests; rerun interactively to approve this action.";
+var HEADLESS_PERMISSION_DENIED_MARKER = "clio-coder run cannot confirm permission requests";
+
+// src/core/bash-exec.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+var BASH_HARD_CAP_BYTES = 16 * 1024 * 1024;
+var CLIO_CONTROL_ENV_KEYS = ["CLIO_CODER_INTERACTIVE", "CLIO_CODER_RESUME_SESSION_ID"];
+var BASH_UPDATE_THROTTLE_MS = 100;
+function buildToolEnv() {
+  const env = { ...process.env };
+  env.AI_AGENT = AI_AGENT_NAME;
+  for (const key of CLIO_CONTROL_ENV_KEYS) {
+    Reflect.deleteProperty(env, key);
+  }
+  return env;
+}
+var LOGIN_ENV_CAPTURE_TIMEOUT_MS = 1e4;
+var loginEnvCapture = null;
+function parseNullDelimitedEnv(raw) {
+  const env = {};
+  for (const entry of raw.split("\0")) {
+    if (entry.length === 0) continue;
+    const eq = entry.indexOf("=");
+    if (eq <= 0) continue;
+    env[entry.slice(0, eq)] = entry.slice(eq + 1);
+  }
+  return typeof env.PATH === "string" && env.PATH.length > 0 ? env : null;
+}
+function captureLoginEnv() {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const child = spawn("/bin/bash", ["-lc", "env -0"], {
+      env: buildToolEnv(),
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish(null);
+    }, LOGIN_ENV_CAPTURE_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code === 0 ? parseNullDelimitedEnv(stdout) : null));
+  });
+}
+async function bashSpawnPlan() {
+  loginEnvCapture ??= captureLoginEnv();
+  const captured = await loginEnvCapture;
+  if (captured === null) return { mode: "-lc", env: buildToolEnv() };
+  const env = { ...process.env, ...captured };
+  env.AI_AGENT = AI_AGENT_NAME;
+  for (const key of CLIO_CONTROL_ENV_KEYS) {
+    Reflect.deleteProperty(env, key);
+  }
+  return { mode: "-c", env };
+}
+function combineBashOutput(result) {
+  const { stdout, stderr } = result;
+  return stderr.length > 0 ? `${stdout}${stdout.endsWith("\n") || stdout.length === 0 ? "" : "\n"}${stderr}` : stdout;
+}
+async function runBashCommand(command, options = {}) {
+  const plan = await bashSpawnPlan();
+  const attribution = withManagedGitCommitAttributionEnvironment(plan.env, {
+    cwd: options.cwd ?? process.cwd(),
+    enabled: gitCommitAttributionEnabled(process.env)
+  });
+  reportCommitAttributionDiagnostic(attribution.diagnostic);
+  return new Promise((resolve) => {
+    const timeout = clampTimerDelayMs(options.timeoutMs ?? 3e5);
+    let aborted = false;
+    let timedOut = false;
+    let settled = false;
+    let timeoutId = null;
+    let killGraceTimer = null;
+    let killSent = false;
+    let stdout = "";
+    let stderr = "";
+    let outputBytes = 0;
+    let outputCapped = false;
+    let updateTimer = null;
+    let updateDirty = false;
+    let lastUpdateAt = 0;
+    const child = spawn("/bin/bash", [plan.mode, command], {
+      ...options.cwd === void 0 ? {} : { cwd: options.cwd },
+      env: attribution.env,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const emitUpdate = () => {
+      if (options.onUpdate === void 0 || !updateDirty) return;
+      updateDirty = false;
+      lastUpdateAt = Date.now();
+      try {
+        options.onUpdate({ stdout, stderr, outputBytes: Math.min(outputBytes, BASH_HARD_CAP_BYTES) });
+      } catch {
+      }
+    };
+    const clearUpdateTimer = () => {
+      if (updateTimer === null) return;
+      clearTimeout(updateTimer);
+      updateTimer = null;
+    };
+    const scheduleUpdate = () => {
+      if (options.onUpdate === void 0) return;
+      updateDirty = true;
+      const delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);
+      if (delay <= 0) {
+        clearUpdateTimer();
+        emitUpdate();
+        return;
+      }
+      updateTimer ??= setTimeout(() => {
+        updateTimer = null;
+        emitUpdate();
+      }, delay);
+    };
+    const finishUpdates = () => {
+      clearUpdateTimer();
+      emitUpdate();
+    };
+    if (options.onUpdate !== void 0) {
+      updateDirty = true;
+      emitUpdate();
+    }
+    const clearKillGraceTimer = () => {
+      if (!killGraceTimer) return;
+      clearTimeout(killGraceTimer);
+      killGraceTimer = null;
+    };
+    const sendSignal = (signalName) => {
+      const pid = child.pid;
+      if (pid && process.platform !== "win32") {
+        try {
+          process.kill(-pid, signalName);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signalName);
+    };
+    const killChild = () => {
+      if (killSent) return;
+      killSent = true;
+      sendSignal("SIGTERM");
+      killGraceTimer = setTimeout(() => {
+        sendSignal("SIGKILL");
+      }, 5e3);
+    };
+    function onAbort() {
+      aborted = true;
+      killChild();
+    }
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        killChild();
+      }, timeout);
+    }
+    if (options.signal?.aborted) {
+      onAbort();
+    } else {
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    }
+    const appendChunk = (target, chunk) => {
+      if (outputCapped) return;
+      outputBytes += chunk.byteLength;
+      if (outputBytes > BASH_HARD_CAP_BYTES) {
+        const remaining = BASH_HARD_CAP_BYTES - (outputBytes - chunk.byteLength);
+        if (remaining > 0) {
+          const slice = chunk.subarray(0, remaining).toString("utf8");
+          if (target === "stdout") stdout += slice;
+          else stderr += slice;
+        }
+        outputCapped = true;
+        scheduleUpdate();
+        killChild();
+        return;
+      }
+      if (target === "stdout") stdout += chunk.toString("utf8");
+      else stderr += chunk.toString("utf8");
+      scheduleUpdate();
+    };
+    child.stdout?.on("data", (chunk) => appendChunk("stdout", chunk));
+    child.stderr?.on("data", (chunk) => appendChunk("stderr", chunk));
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      clearKillGraceTimer();
+      finishUpdates();
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve({
+        error,
+        stdout,
+        stderr,
+        exitCode: null,
+        signal: null,
+        aborted,
+        timedOut,
+        outputCapped
+      });
+    });
+    child.on("close", (code, signalName) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      clearKillGraceTimer();
+      finishUpdates();
+      options.signal?.removeEventListener("abort", onAbort);
+      const error = code === 0 && signalName === null ? null : {
+        name: "Error",
+        message: signalName ? `command terminated by ${signalName}` : `command exited with code ${code ?? "?"}`,
+        code: code ?? void 0,
+        signal: signalName ?? void 0
+      };
+      resolve({ error, stdout, stderr, exitCode: code, signal: signalName, aborted, timedOut, outputCapped });
+    });
+  });
+}
+
+export {
+  HEADLESS_PERMISSION_DENIED_REASON,
+  HEADLESS_PERMISSION_DENIED_MARKER,
+  BASH_HARD_CAP_BYTES,
+  combineBashOutput,
+  runBashCommand
+};
+//# sourceMappingURL=chunk-J7CWMCQD.js.map

package/dist/{chunk-K5XEMXTI.js → chunk-JVCV3ICN.js}

@@ -44,4 +44,4 @@ export {
   FULL_PROJECT_CONTEXT_MAX_LINES,
   classifyProjectPreload
 };
-//# sourceMappingURL=chunk-K5XEMXTI.js.map
+//# sourceMappingURL=chunk-JVCV3ICN.js.map

package/dist/chunk-KZWTDYJF.js

@@ -0,0 +1,217 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  readLayeredSettings,
+  readStrictLayeredSettings
+} from "./chunk-CBCAPZAA.js";
+import {
+  formatBootTrace
+} from "./chunk-HKIYEGME.js";
+import {
+  initializeClioHome
+} from "./chunk-BMEMKKIT.js";
+import {
+  readSettings
+} from "./chunk-A3CYT5EX.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  findEngineEnvKeys,
+  getEngineEnvApiKey
+} from "./chunk-YXLYO42X.js";
+import {
+  clioConfigDir
+} from "./chunk-BNAZZHFG.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/clio.ts
+init_esm_shims();
+
+// src/cli/default-target.ts
+init_esm_shims();
+
+// src/domains/providers/auth/boot-status.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function storedCredentialPresent(providerId) {
+  const path = join(clioConfigDir(), "credentials.yaml");
+  if (!existsSync(path)) return false;
+  try {
+    const root = record((0, import_yaml.parse)(readFileSync(path, "utf8")));
+    const entry = record(record(root?.entries)?.[providerId]);
+    if (!entry) return false;
+    if (entry.type === "api_key") return typeof entry.key === "string" && entry.key.trim().length > 0;
+    if (entry.type === "oauth") {
+      return typeof entry.access === "string" && typeof entry.refresh === "string" && typeof entry.expires === "number";
+    }
+    return typeof entry.key === "string" && entry.key.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function environmentCredentialPresent(providerId, explicitEnvVar) {
+  if (explicitEnvVar && process.env[explicitEnvVar]?.trim()) return true;
+  for (const name of findEngineEnvKeys(providerId) ?? []) {
+    if (process.env[name]?.trim()) return true;
+  }
+  return Boolean(getEngineEnvApiKey(providerId)?.trim());
+}
+function bootAuthStatus(target, runtime) {
+  const required = runtime.auth === "oauth" || runtime.auth === "api-key" && (Boolean(target.auth?.apiKeyEnvVar || target.auth?.apiKeyRef || target.auth?.oauthProfile) || runtime.tier === "cloud" || Boolean(runtime.credentialsEnvVar));
+  const providerId = target.auth?.oauthProfile?.trim() || target.auth?.apiKeyRef?.trim() || runtime.oauthProviderId || runtime.id;
+  if (!required) return { providerId, required: false, available: true };
+  const explicitEnvVar = target.auth?.apiKeyEnvVar ?? runtime.credentialsEnvVar;
+  return {
+    providerId,
+    required: true,
+    available: storedCredentialPresent(providerId) || environmentCredentialPresent(providerId, explicitEnvVar)
+  };
+}
+
+// src/domains/providers/runtimes/boot-manifest.ts
+init_esm_shims();
+var BUILTIN_RUNTIME_BOOT_MANIFEST = [
+  { id: "alcf", kind: "http", tier: "cloud", auth: "oauth" },
+  { id: "anthropic", kind: "http", tier: "cloud", auth: "api-key", credentialsEnvVar: "ANTHROPIC_API_KEY" },
+  { id: "anthropic-max", kind: "http", tier: "cloud", auth: "oauth", oauthProviderId: "anthropic" },
+  { id: "bedrock", kind: "http", tier: "cloud", auth: "aws-sdk" },
+  { id: "deepseek", kind: "http", tier: "cloud", auth: "api-key", credentialsEnvVar: "DEEPSEEK_API_KEY" },
+  { id: "google", kind: "http", tier: "cloud", auth: "api-key", credentialsEnvVar: "GOOGLE_API_KEY" },
+  { id: "groq", kind: "http", tier: "cloud", auth: "api-key", credentialsEnvVar: "GROQ_API_KEY" },
+  { id: "mistral", kind: "http", tier: "cloud", auth: "api-key", credentialsEnvVar: "MISTRAL_API_KEY" },
+  { id: "openai", kind: "http", tier: "cloud", auth: "api-key", credentialsEnvVar: "OPENAI_API_KEY" },
+  { id: "openai-codex", kind: "http", tier: "cloud", auth: "oauth" },
+  { id: "openrouter", kind: "http", tier: "cloud", auth: "api-key", credentialsEnvVar: "OPENROUTER_API_KEY" },
+  { id: "lemonade-anthropic", kind: "http", tier: "local-native", auth: "api-key" },
+  { id: "lemonade", kind: "http", tier: "local-native", auth: "api-key" },
+  { id: "llamacpp", kind: "http", tier: "local-native", auth: "api-key" },
+  { id: "llamacpp-anthropic", kind: "http", tier: "local-native", auth: "api-key" },
+  { id: "llamacpp-completion", kind: "http", tier: "local-native", auth: "api-key" },
+  { id: "llamacpp-embed", kind: "http", tier: "local-native", auth: "api-key" },
+  { id: "llamacpp-rerank", kind: "http", tier: "local-native", auth: "api-key" },
+  { id: "lmstudio", aliases: ["lmstudio-native"], kind: "http", tier: "local-native", auth: "api-key" },
+  { id: "ollama-native", kind: "http", tier: "local-native", auth: "none" },
+  { id: "anthropic-compat", kind: "http", tier: "protocol", auth: "api-key" },
+  { id: "openai-compat", kind: "http", tier: "protocol", auth: "api-key" },
+  { id: "sglang", kind: "http", tier: "local-native", auth: "api-key" },
+  { id: "vllm", kind: "http", tier: "local-native", auth: "api-key" },
+  { id: "claude-code", kind: "subprocess", tier: "subscription", auth: "claude-cli" },
+  { id: "claude-sdk", kind: "sdk", tier: "subscription", auth: "claude-cli" },
+  { id: "antigravity-code", kind: "subprocess", tier: "subscription", auth: "none" }
+];
+function findBuiltinRuntimeBootMetadata(id) {
+  return BUILTIN_RUNTIME_BOOT_MANIFEST.find((runtime) => runtime.id === id || runtime.aliases?.includes(id)) ?? null;
+}
+
+// src/cli/default-target.ts
+function classifyDefaultTarget(settings = readSettings()) {
+  const targetId = settings.orchestrator.target;
+  if (!targetId) return { kind: "no-target" };
+  const target = settings.targets.find((entry) => entry.id === targetId);
+  if (!target) return { kind: "no-target" };
+  const runtime = findBuiltinRuntimeBootMetadata(target.runtime);
+  if (runtime?.kind !== "http") {
+    return { kind: "ineligible-runtime", targetId, runtime: target.runtime };
+  }
+  const auth = bootAuthStatus(target, runtime);
+  if (auth.available) return { kind: "usable" };
+  return { kind: "missing-credential", targetId, store: auth.providerId };
+}
+function describeVerdict(verdict) {
+  switch (verdict.kind) {
+    case "no-target":
+      return "No model target is configured.";
+    case "ineligible-runtime":
+      return `Target '${verdict.targetId}' runs on '${verdict.runtime}', which cannot drive the main agent.`;
+    default:
+      return "No usable default target is configured.";
+  }
+}
+
+// src/cli/clio.ts
+function terminalLeaseEligible(options, env = process.env) {
+  return !options.headless && !options.acp && env.CLIO_CODER_INTERACTIVE === "1";
+}
+async function runClioCommand(options = {}) {
+  if (!options.headless && !options.acp && process.env.CLIO_CODER_INTERACTIVE === void 0 && process.stdin.isTTY) {
+    process.env.CLIO_CODER_INTERACTIVE = "1";
+  }
+  let startupSettings;
+  if (terminalLeaseEligible(options)) {
+    initializeClioHome();
+    startupSettings = readStrictLayeredSettings(process.cwd()).settings;
+    const verdict = classifyDefaultTarget(startupSettings);
+    if (verdict.kind === "missing-credential") {
+      process.stdout.write(
+        `Target '${verdict.targetId}' has no stored credential under '${verdict.store}'.
+Run \`clio-coder auth login ${verdict.store}\` if the endpoint requires one; local runtimes that ignore keys work as is.
+`
+      );
+    } else if (verdict.kind !== "usable") {
+      process.stdout.write(`${describeVerdict(verdict)} Starting \`clio-coder configure\`.
+`);
+      const { runConfigureCommand } = await import("./configure-4GAP54ZW.js");
+      const configured = await runConfigureCommand([]);
+      if (configured !== 0) return configured;
+      startupSettings = readStrictLayeredSettings(process.cwd()).settings;
+    }
+  }
+  let terminalLease;
+  try {
+    if (terminalLeaseEligible(options)) {
+      const { createProcessTerminalLease, instantShellEnabled } = await import("./terminal-lease-BNAHVHBS.js");
+      if (instantShellEnabled()) {
+        let stage0FrameId = null;
+        terminalLease = createProcessTerminalLease({
+          settings: startupSettings ?? readLayeredSettings(process.cwd()).settings,
+          onStage0Commit: (frameId) => {
+            stage0FrameId = frameId;
+          }
+        });
+        if (stage0FrameId !== null) {
+          const line = formatBootTrace("Stage 0 shell commit", `frameId=${stage0FrameId}`);
+          if (line) terminalLease.deferDiagnostic("stderr", line);
+        }
+      }
+    }
+    if (terminalLease && process.env.NODE_ENV === "test") {
+      const requestedDelay = Number.parseInt(process.env.CLIO_CODER_TEST_STAGE1_DELAY_MS ?? "0", 10);
+      const delayMs = Number.isFinite(requestedDelay) ? Math.max(0, Math.min(5e3, requestedDelay)) : 0;
+      if (delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+      if (process.env.CLIO_CODER_TEST_STAGE1_FAIL === "1") {
+        throw new Error("injected Stage 1 hydration failure");
+      }
+    }
+    const { bootOrchestrator } = await import("./orchestrator-EM5MC3HM.js");
+    const result = await bootOrchestrator({
+      ...options,
+      ...startupSettings ? { startupSettings } : {},
+      ...terminalLease ? { terminalLease } : {}
+    });
+    return result.exitCode;
+  } catch (error) {
+    try {
+      await terminalLease?.fail();
+    } catch (cleanupError) {
+      process.stderr.write(
+        `Clio Coder: terminal cleanup also failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}
+`
+      );
+    }
+    throw error;
+  }
+}
+
+export {
+  terminalLeaseEligible,
+  runClioCommand
+};
+//# sourceMappingURL=chunk-KZWTDYJF.js.map