@iowarp/clio-coder 0.3.0

package/dist/auth-O6HYIJ6J.js

@@ -0,0 +1,521 @@
+import {
+  createDelayedManualCodeInput,
+  promptOAuthSelection
+} from "./chunk-KKKPTZLM.js";
+import {
+  terminalColumns,
+  wrapPlain
+} from "./chunk-ME6DNWIU.js";
+import {
+  credentialWriteFailed,
+  printPlaintextCredentialWarning
+} from "./chunk-PIDUD6M2.js";
+import {
+  columnWidths,
+  formatColumnRow,
+  formatColumns,
+  printError,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import {
+  EMPTY_CAPABILITIES,
+  getRuntimeRegistry,
+  listProviderSupportEntries,
+  registerBuiltinRuntimes,
+  resolveProviderReference,
+  supportGroupLabel
+} from "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import {
+  readSettings
+} from "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import {
+  authNotRequiredStatus,
+  openAuthStorage,
+  registerClioOAuthProviders,
+  resolveRuntimeAuthTarget,
+  targetRequiresAuth
+} from "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/auth.ts
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+
+// src/cli/provider-target.ts
+var CONNECTABLE_LIST_CAPTION = "runtimes clio authenticates itself. run `clio-coder configure --list` for every registered runtime, including those that authenticate through their own tool or need no credential.";
+function ensureSetupRuntimeRegistry() {
+  registerClioOAuthProviders();
+  const registry = getRuntimeRegistry();
+  if (registry.list().length === 0) registerBuiltinRuntimes(registry);
+}
+function resolveCliProviderReference(input2) {
+  ensureSetupRuntimeRegistry();
+  const resolved = resolveProviderReference(input2, readSettings(), (runtimeId) => getRuntimeRegistry().get(runtimeId));
+  if (resolved) return resolved;
+  const oauthProvider = openAuthStorage().getOAuthProviders().find((provider) => provider.id === input2);
+  if (!oauthProvider) return null;
+  return {
+    input: input2,
+    target: null,
+    runtime: {
+      id: oauthProvider.id,
+      displayName: oauthProvider.name,
+      kind: "http",
+      apiFamily: "openai-codex-responses",
+      auth: "oauth",
+      defaultCapabilities: EMPTY_CAPABILITIES,
+      synthesizeModel: () => {
+        throw new Error(`runtime ${oauthProvider.id} is auth-only in this context`);
+      }
+    },
+    authTarget: {
+      providerId: oauthProvider.id,
+      runtimeAuth: "oauth"
+    }
+  };
+}
+function listConnectableProviderRows() {
+  ensureSetupRuntimeRegistry();
+  const settings = readSettings();
+  const auth = openAuthStorage();
+  return listProviderSupportEntries(getRuntimeRegistry().list()).filter((entry) => entry.connectable).map((entry) => {
+    const runtime = getRuntimeRegistry().get(entry.runtimeId);
+    const status = runtime ? auth.statusForTarget(resolveRuntimeAuthTarget(runtime), { includeFallback: false }) : null;
+    return {
+      entry,
+      status,
+      targetCount: settings.targets.filter((target) => target.runtime === entry.runtimeId).length
+    };
+  });
+}
+function renderConnectableProviderRows(rows) {
+  let lastGroup = null;
+  const lines = [];
+  const renderedRows = rows.map((row) => {
+    const status = row.status?.available ? row.status.source === "environment" ? `env${row.status.detail ? `:${row.status.detail}` : ""}` : row.status.source : "disconnected";
+    return {
+      group: row.entry.group,
+      cells: [row.entry.runtimeId, row.entry.label, status, `targets=${row.targetCount}`]
+    };
+  });
+  const widths = columnWidths(renderedRows.map((row) => row.cells));
+  for (const row of renderedRows) {
+    if (row.group !== lastGroup) {
+      lastGroup = row.group;
+      lines.push(`${supportGroupLabel(row.group)}:`);
+    }
+    lines.push(`  ${formatColumnRow(row.cells, widths)}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/cli/auth.ts
+var USAGE = `usage: clio-coder auth list
+       clio-coder auth status [target-or-runtime]
+       clio-coder auth login [target-or-runtime] [--api-key <value>]
+       clio-coder auth logout [target-or-runtime]
+`;
+function parseAuthTargetArgs(args, verb) {
+  const parsed = { help: false };
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === void 0) continue;
+    if (arg === "--help" || arg === "-h") {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === "--api-key") {
+      const value = args[i + 1];
+      if (!value) throw new Error("--api-key requires a value");
+      parsed.apiKey = value;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+    if (parsed.target) throw new Error(`auth ${verb} accepts at most one target or runtime`);
+    parsed.target = arg;
+  }
+  return parsed;
+}
+function printConnectableListing(rows) {
+  process.stdout.write(renderConnectableProviderRows(rows));
+  for (const line of wrapPlain(CONNECTABLE_LIST_CAPTION, terminalColumns())) {
+    process.stdout.write(`${line}
+`);
+  }
+}
+function printStatusLine(id, label, type, present, source) {
+  process.stdout.write(formatColumns([[id, label, type ?? "-", present ? "present" : "absent", source]]));
+}
+function warnIfCredentialsDamaged(auth) {
+  const damage = auth.damageReason();
+  if (damage === null) return;
+  process.stderr.write(`warning: the credentials file could not be fully read: ${damage}
+`);
+  process.stderr.write("warning: entries below may be understated. Nothing will be written until it is repaired.\n");
+}
+function renderStatusRows(rows) {
+  return formatColumns(
+    rows.map((row) => {
+      const status = row.status;
+      if (status === null) {
+        return [row.entry.runtimeId, row.entry.label, "-", "unknown", "no auth probe available"];
+      }
+      return [
+        row.entry.runtimeId,
+        row.entry.label,
+        status.credentialType ?? "-",
+        status.available ? "present" : "absent",
+        status.detail ?? status.source
+      ];
+    })
+  );
+}
+function defaultAuthTarget(rows) {
+  const settings = readSettings();
+  const activeTarget = settings.orchestrator.target ? settings.targets.find((entry) => entry.id === settings.orchestrator.target) : void 0;
+  if (activeTarget && rows.some((row) => row.entry.runtimeId === activeTarget.runtime)) {
+    return activeTarget.runtime;
+  }
+  const configured = rows.find((row) => row.targetCount > 0);
+  if (configured) return configured.entry.runtimeId;
+  return rows[0]?.entry.runtimeId;
+}
+async function promptForLoginTarget(rows) {
+  if (rows.length === 0) {
+    printError("no auth-capable runtimes are registered");
+    return null;
+  }
+  const rl = createInterface({ input, output });
+  const defaultTarget = defaultAuthTarget(rows) ?? rows[0]?.entry.runtimeId ?? "";
+  try {
+    process.stdout.write("Authenticate a runtime:\n");
+    let lastGroup = null;
+    for (const [index, row] of rows.entries()) {
+      if (row.entry.group !== lastGroup) {
+        lastGroup = row.entry.group;
+        process.stdout.write(`  ${supportGroupLabel(row.entry.group)}:
+`);
+      }
+      const status = row.status?.available ? row.status.source === "environment" ? `env:${row.status.detail ?? row.entry.runtimeId}` : row.status.source : row.status === null ? "native-cli" : "disconnected";
+      process.stdout.write(
+        `    ${String(index + 1).padStart(2)}. ${row.entry.runtimeId.padEnd(22)} ${status.padEnd(18)} targets=${row.targetCount}
+`
+      );
+    }
+    for (const line of wrapPlain(CONNECTABLE_LIST_CAPTION, terminalColumns())) {
+      process.stdout.write(`${line}
+`);
+    }
+    process.stdout.write("\n");
+    for (; ; ) {
+      const answer = (await rl.question(`Selection (number or runtime id) [${defaultTarget}]: `)).trim();
+      const value = answer.length > 0 ? answer : defaultTarget;
+      const numeric = Number(value);
+      if (Number.isInteger(numeric) && numeric >= 1 && numeric <= rows.length) {
+        return rows[numeric - 1]?.entry.runtimeId ?? null;
+      }
+      if (rows.some((row) => row.entry.runtimeId === value)) return value;
+      process.stderr.write(`unknown selection: ${value}
+`);
+    }
+  } catch {
+    return null;
+  } finally {
+    rl.close();
+  }
+}
+function storedCredentialRows(rows) {
+  return rows.filter((row) => row.status?.source === "stored-api-key" || row.status?.source === "stored-oauth");
+}
+function statusForResolvedTarget(resolved, auth) {
+  if (resolved.target && !targetRequiresAuth(resolved.target, resolved.runtime)) {
+    return authNotRequiredStatus(resolved.authTarget.providerId);
+  }
+  if (!resolved.target && resolved.runtime.auth !== "api-key" && resolved.runtime.auth !== "oauth") {
+    return authNotRequiredStatus(resolved.authTarget.providerId);
+  }
+  return auth.statusForTarget(resolved.authTarget, { includeFallback: false });
+}
+async function promptForLogoutTarget(rows) {
+  if (rows.length === 0) {
+    printError("no stored target credentials");
+    return null;
+  }
+  const rl = createInterface({ input, output });
+  const defaultTarget = defaultAuthTarget(rows) ?? rows[0]?.entry.runtimeId ?? "";
+  try {
+    process.stdout.write("Remove stored credentials:\n");
+    let lastGroup = null;
+    for (const [index, row] of rows.entries()) {
+      if (row.entry.group !== lastGroup) {
+        lastGroup = row.entry.group;
+        process.stdout.write(`  ${supportGroupLabel(row.entry.group)}:
+`);
+      }
+      process.stdout.write(
+        `    ${String(index + 1).padStart(2)}. ${row.entry.runtimeId.padEnd(22)} ${String(row.status?.source ?? "disconnected")}
+`
+      );
+    }
+    process.stdout.write("\n");
+    for (; ; ) {
+      const answer = (await rl.question(`Selection (number or runtime id) [${defaultTarget}]: `)).trim();
+      const value = answer.length > 0 ? answer : defaultTarget;
+      const numeric = Number(value);
+      if (Number.isInteger(numeric) && numeric >= 1 && numeric <= rows.length) {
+        return rows[numeric - 1]?.entry.runtimeId ?? null;
+      }
+      if (rows.some((row) => row.entry.runtimeId === value)) return value;
+      process.stderr.write(`unknown selection: ${value}
+`);
+    }
+  } catch {
+    return null;
+  } finally {
+    rl.close();
+  }
+}
+async function runLogin(args) {
+  let parsed;
+  try {
+    parsed = parseAuthTargetArgs(args, "login");
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(USAGE);
+    return 2;
+  }
+  if (parsed.help) {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  if (!parsed.target) {
+    if (!input.isTTY || !output.isTTY) {
+      printConnectableListing(listConnectableProviderRows());
+      process.stderr.write(USAGE);
+      return 2;
+    }
+    const picked = await promptForLoginTarget(listConnectableProviderRows());
+    if (!picked) return 0;
+    parsed.target = picked;
+  }
+  const resolved = resolveCliProviderReference(parsed.target);
+  if (!resolved) {
+    printError(`unknown target or runtime: ${parsed.target}`);
+    process.stderr.write(USAGE);
+    return 2;
+  }
+  const auth = openAuthStorage();
+  if (resolved.runtime.authNotice) process.stdout.write(`note: ${resolved.runtime.authNotice}
+`);
+  if (resolved.runtime.auth === "oauth") {
+    const rl2 = createInterface({ input, output });
+    const manualCodeInput = createDelayedManualCodeInput(
+      rl2,
+      "Paste verification code if the browser flow does not return automatically: "
+    );
+    try {
+      await auth.login(resolved.authTarget.providerId, {
+        onAuth: ({ url, instructions }) => {
+          process.stdout.write(`${url}
+`);
+          if (instructions) process.stdout.write(`${instructions}
+`);
+          process.stdout.write("Waiting for the browser callback. A manual code prompt will appear if needed.\n");
+        },
+        onDeviceCode: ({ verificationUri, userCode }) => {
+          process.stdout.write(`${verificationUri}
+`);
+          process.stdout.write(`Enter code: ${userCode}
+`);
+        },
+        onPrompt: async (prompt) => {
+          const answer = await rl2.question(`${prompt.message}${prompt.allowEmpty ? " " : ": "}`);
+          return prompt.allowEmpty ? answer : answer.trim();
+        },
+        onSelect: (prompt) => promptOAuthSelection(rl2, prompt),
+        onManualCodeInput: manualCodeInput.onManualCodeInput,
+        onProgress: (message) => {
+          process.stderr.write(`${message}
+`);
+        }
+      });
+      if (credentialWriteFailed(auth, `credential for ${resolved.authTarget.providerId} was not stored`)) return 1;
+      printOk(`authenticated ${resolved.authTarget.providerId}`);
+      return 0;
+    } catch (error) {
+      printError(error instanceof Error ? error.message : String(error));
+      return 1;
+    } finally {
+      manualCodeInput.cancel();
+      rl2.close();
+    }
+  }
+  if (resolved.runtime.auth !== "api-key") {
+    printError(`runtime ${resolved.runtime.id} does not support interactive auth login`);
+    process.stderr.write(
+      `  it authenticates as '${resolved.runtime.auth}', outside clio: \`clio-coder auth status ${resolved.runtime.id}\` reports its state, and \`clio-coder configure --list\` shows how it is registered
+`
+    );
+    return 1;
+  }
+  let apiKey = parsed.apiKey;
+  const rl = createInterface({ input, output });
+  try {
+    if (!apiKey) {
+      apiKey = (await rl.question(`API key for ${resolved.runtime.displayName}: `)).trim();
+    }
+    if (!apiKey) {
+      printError("empty API key");
+      return 1;
+    }
+    try {
+      auth.setApiKey(resolved.authTarget.providerId, apiKey);
+    } catch (error) {
+      printError(error instanceof Error ? error.message : String(error));
+      return 1;
+    }
+    if (credentialWriteFailed(auth, `credential for ${resolved.authTarget.providerId} was not stored`)) return 1;
+    printOk(`authenticated ${resolved.authTarget.providerId}`);
+    printPlaintextCredentialWarning();
+    return 0;
+  } finally {
+    rl.close();
+  }
+}
+async function runStatus(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  if (args.some((arg) => arg.startsWith("-"))) {
+    printError(`unknown flag: ${args.find((arg) => arg.startsWith("-"))}`);
+    process.stderr.write(USAGE);
+    return 2;
+  }
+  if (args.length > 1) {
+    printError("auth status accepts at most one target or runtime");
+    process.stderr.write(USAGE);
+    return 2;
+  }
+  const auth = openAuthStorage();
+  warnIfCredentialsDamaged(auth);
+  const target = args[0];
+  if (target) {
+    const resolved = resolveCliProviderReference(target);
+    if (!resolved) {
+      printError(`unknown target or runtime: ${target}`);
+      return 2;
+    }
+    const status = statusForResolvedTarget(resolved, auth);
+    printStatusLine(
+      resolved.authTarget.providerId,
+      resolved.runtime.displayName,
+      status.credentialType,
+      status.available,
+      status.detail ?? status.source
+    );
+    return status.available ? 0 : 1;
+  }
+  process.stdout.write(renderStatusRows(listConnectableProviderRows()));
+  return 0;
+}
+function runLogout(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  if (args.some((arg) => arg.startsWith("-"))) {
+    printError(`unknown flag: ${args.find((arg) => arg.startsWith("-"))}`);
+    process.stderr.write(USAGE);
+    return 2;
+  }
+  const target = args[0];
+  if (!target) {
+    const rows = storedCredentialRows(listConnectableProviderRows());
+    if (!input.isTTY || !output.isTTY) {
+      process.stdout.write(renderConnectableProviderRows(rows));
+      process.stderr.write(USAGE);
+      return 2;
+    }
+    return promptForLogoutTarget(rows).then((picked) => picked ? runLogout([picked]) : 1);
+  }
+  if (args.length > 1) {
+    printError("auth logout accepts at most one target or runtime");
+    process.stderr.write(USAGE);
+    return 2;
+  }
+  const resolved = resolveCliProviderReference(target);
+  if (!resolved) {
+    printError(`unknown target or runtime: ${target}`);
+    process.stderr.write(USAGE);
+    return 2;
+  }
+  const auth = openAuthStorage();
+  warnIfCredentialsDamaged(auth);
+  const status = statusForResolvedTarget(resolved, auth);
+  if (!status.available) {
+    printError(
+      auth.damageReason() === null ? `no stored credential for ${resolved.authTarget.providerId}` : `cannot tell whether ${resolved.authTarget.providerId} is stored: the credentials file could not be fully read`
+    );
+    return 1;
+  }
+  if (status.source === "environment") {
+    printError(
+      `credential for ${resolved.authTarget.providerId} comes from ${status.detail ?? "the environment"}; clear the env var to log out`
+    );
+    return 1;
+  }
+  if (status.source !== "stored-api-key" && status.source !== "stored-oauth") {
+    printError(`cannot remove credential for ${resolved.authTarget.providerId} from source ${status.source}`);
+    return 1;
+  }
+  try {
+    auth.logout(resolved.authTarget.providerId);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+  if (credentialWriteFailed(auth, `credential for ${resolved.authTarget.providerId} was not removed`)) return 1;
+  printOk(`removed credential for ${resolved.authTarget.providerId}`);
+  return 0;
+}
+async function runAuthCommand(args) {
+  const subcommand = args[0] ?? "status";
+  const rest = args.slice(1);
+  if (subcommand === "list") {
+    if (rest.includes("--help") || rest.includes("-h")) {
+      process.stdout.write(USAGE);
+      return 0;
+    }
+    if (rest.length > 0 && rest.some((arg) => arg !== "--help" && arg !== "-h")) {
+      printError("auth list does not accept target arguments");
+      process.stderr.write(USAGE);
+      return 2;
+    }
+    warnIfCredentialsDamaged(openAuthStorage());
+    printConnectableListing(listConnectableProviderRows());
+    return 0;
+  }
+  if (subcommand === "status") return runStatus(rest);
+  if (subcommand === "login") return runLogin(rest);
+  if (subcommand === "logout") return runLogout(rest);
+  if (subcommand === "--help" || subcommand === "-h") {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+  printError(`unknown auth subcommand: ${subcommand}`);
+  process.stderr.write(USAGE);
+  return 2;
+}
+export {
+  runAuthCommand
+};
+//# sourceMappingURL=auth-O6HYIJ6J.js.map

package/dist/chunk-262G75JS.js

@@ -0,0 +1,35 @@
+// src/domains/providers/probe/fingerprint.ts
+async function fetchWithTimeout(url, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { signal: controller.signal });
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fingerprintNativeRuntime(baseUrl) {
+  const trimmed = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  const lmStudioV1 = await fetchWithTimeout(`${trimmed}/api/v1/models`, 750);
+  if (lmStudioV1?.ok) return { runtimeId: "lmstudio-native", displayName: "LM Studio" };
+  const lmStudioV0 = await fetchWithTimeout(`${trimmed}/api/v0/models`, 750);
+  if (lmStudioV0?.ok) return { runtimeId: "lmstudio-native", displayName: "LM Studio" };
+  const ollama = await fetchWithTimeout(`${trimmed}/api/version`, 750);
+  if (ollama?.ok) {
+    try {
+      const data = await ollama.json();
+      if (typeof data.version === "string") {
+        return { runtimeId: "ollama-native", displayName: "Ollama" };
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+
+export {
+  fingerprintNativeRuntime
+};
+//# sourceMappingURL=chunk-262G75JS.js.map