@dmrlzz/davecode 0.0.0-stage → 0.3.0

package/dist/accounts-MTMGYKEP.js

@@ -0,0 +1,724 @@
+import {
+  PromptCancelledError
+} from "./chunk-IC3TDONV.js";
+import {
+  openAccounts,
+  resolveAccount
+} from "./chunk-IVZHKUCD.js";
+import {
+  table,
+  truncate
+} from "./chunk-SF5ZEAP4.js";
+import {
+  printJson
+} from "./chunk-DYQ56FBT.js";
+import "./chunk-VVCXGQMY.js";
+import {
+  detectProjectRoot,
+  spawnInteractive,
+  which
+} from "./chunk-PIIJ3RSI.js";
+import {
+  CliError,
+  EXIT
+} from "./chunk-7XVXEO7U.js";
+import {
+  CLI_LOGINS,
+  EXPERIMENTAL_PROVIDER_KINDS,
+  SUBSCRIPTION_PROVIDER_KINDS,
+  SandboxManager,
+  cliBinaryFor,
+  globalPaths,
+  loginEnv
+} from "./chunk-C7FDRA3U.js";
+
+// src/commands/accounts.ts
+import { createInterface } from "readline";
+
+// src/lib/account-flow.ts
+var PROVIDERS = [
+  { kind: "anthropic", name: "Anthropic API", auth: "api-key", defaultLabel: "Anthropic" },
+  { kind: "openai", name: "OpenAI API", auth: "api-key", defaultLabel: "OpenAI" },
+  { kind: "gemini", name: "Google Gemini API", auth: "api-key", defaultLabel: "Gemini" },
+  {
+    kind: "openai-compatible",
+    name: "OpenRouter or another OpenAI-compatible provider",
+    auth: "optional-key",
+    defaultLabel: "OpenRouter"
+  },
+  {
+    kind: "claude-cli",
+    name: "Claude Code CLI (your Claude login)",
+    auth: "cli-login",
+    defaultLabel: "Claude Code",
+    binary: "claude"
+  },
+  {
+    kind: "codex-cli",
+    name: "Codex CLI (your ChatGPT/OpenAI login)",
+    auth: "cli-login",
+    defaultLabel: "Codex",
+    binary: "codex"
+  },
+  {
+    kind: "gemini-cli",
+    name: "Gemini CLI (your Google login)",
+    auth: "cli-login",
+    defaultLabel: "Gemini CLI",
+    binary: "gemini"
+  },
+  {
+    kind: "gemini-web",
+    name: "Gemini web session (experimental)",
+    auth: "browser",
+    defaultLabel: "Gemini web"
+  }
+];
+function providerInfo(kind) {
+  return PROVIDERS.find((p) => p.kind === kind);
+}
+var DEFAULT_COMPATIBLE_URL = "https://openrouter.ai/api/v1";
+var GEMINI_WEB_TOS = "gemini-web automates the consumer Gemini web app through a browser profile. This likely violates Google\u2019s Terms of Service and your account can be rate-limited or suspended.";
+var ROTATION_TOS = "Rotating several subscription logins of the same provider to get around per-account limits may violate the provider\u2019s consumer terms; accounts can be rate-limited or suspended.";
+function accountPolicy(provider, config, existing) {
+  const warnings = [];
+  if (EXPERIMENTAL_PROVIDER_KINDS.includes(provider)) {
+    if (!config.experimental.geminiWeb) {
+      return {
+        warnings,
+        blocked: {
+          message: `${provider} is experimental and disabled. ${GEMINI_WEB_TOS}`,
+          hint: 'If you accept the risk, set "experimental": { "geminiWeb": true } in ~/.davecode/config.json (or DAVECODE_EXPERIMENTAL_GEMINI_WEB=1).'
+        }
+      };
+    }
+    warnings.push(GEMINI_WEB_TOS);
+  }
+  const sameProvider = existing.filter((a) => a.provider === provider).length;
+  if (SUBSCRIPTION_PROVIDER_KINDS.includes(provider) && sameProvider > 0) {
+    if (!config.experimental.multiAccountRotation) {
+      return {
+        warnings,
+        blocked: {
+          message: `You already have a ${provider} account. ${ROTATION_TOS}`,
+          hint: 'If you accept the risk, set "experimental": { "multiAccountRotation": true } in ~/.davecode/config.json (or DAVECODE_EXPERIMENTAL_MULTI_ACCOUNT_ROTATION=1).'
+        }
+      };
+    }
+    warnings.push(ROTATION_TOS);
+  }
+  return { warnings };
+}
+var LIMIT_KEYS = [
+  "tpm",
+  "rpm",
+  "tokens5h",
+  "requests5h",
+  "tokensDaily",
+  "requestsDaily"
+];
+function parseLimits(pairs = []) {
+  const limits = {};
+  for (const pair of pairs) {
+    const [rawKey, rawValue] = pair.split("=", 2);
+    const key = LIMIT_KEYS.find((k) => k.toLowerCase() === rawKey?.trim().toLowerCase());
+    const value = Number(rawValue);
+    if (!key) {
+      throw new CliError(`Unknown limit ${JSON.stringify(rawKey)}`, {
+        hint: `Use one of: ${LIMIT_KEYS.join(", ")} (e.g. --limit tokens5h=500000)`
+      });
+    }
+    if (!Number.isInteger(value) || value <= 0) {
+      throw new CliError(
+        `Limit ${key} must be a positive integer, got ${JSON.stringify(rawValue)}`
+      );
+    }
+    limits[key] = value;
+  }
+  return limits;
+}
+function validateUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" || url.protocol === "https:" ? void 0 : "must be an http(s) URL";
+  } catch {
+    return "must be a valid URL, e.g. http://localhost:11434/v1";
+  }
+}
+function requireProvider(value) {
+  if (!value) {
+    throw new CliError("Missing --provider", {
+      hint: `One of: ${PROVIDERS.map((p) => p.kind).join(", ")}`
+    });
+  }
+  const info = providerInfo(value);
+  if (!info) {
+    throw new CliError(`Unknown provider ${JSON.stringify(value)}`, {
+      hint: `One of: ${PROVIDERS.map((p) => p.kind).join(", ")}`
+    });
+  }
+  return info;
+}
+async function secretFromFlags(flags, sources) {
+  const chosen = [flags.secret !== void 0, !!flags.secretEnv, !!flags.secretStdin].filter(
+    Boolean
+  );
+  if (chosen.length > 1) {
+    throw new CliError("Use only one of --secret, --secret-env and --secret-stdin");
+  }
+  if (flags.secretStdin) {
+    const value2 = (await sources.readStdin()).trim();
+    if (!value2) throw new CliError("No secret received on stdin");
+    return value2;
+  }
+  if (flags.secretEnv) {
+    const value2 = sources.env[flags.secretEnv]?.trim();
+    if (!value2) throw new CliError(`Environment variable ${flags.secretEnv} is empty or unset`);
+    return value2;
+  }
+  const value = flags.secret?.trim();
+  return value ? value : void 0;
+}
+function providerConfig(info, values) {
+  const config = {};
+  if (values.baseUrl) config.baseUrl = values.baseUrl.replace(/\/+$/, "");
+  if (values.models && values.models.length > 0) config.models = [...new Set(values.models)];
+  if (values.defaultModel) config.defaultModel = values.defaultModel;
+  if (values.binaryPath && info.auth === "cli-login") config.binaryPath = values.binaryPath;
+  return config;
+}
+async function accountFromFlags(flags, sources) {
+  const info = requireProvider(flags.provider);
+  const secret = await secretFromFlags(flags, sources);
+  if (info.auth === "api-key" && !secret) {
+    throw new CliError(`${info.name} needs an API key`, {
+      hint: "Pass it with --secret-env <VAR> or pipe it with --secret-stdin."
+    });
+  }
+  if (secret && (info.auth === "cli-login" || info.auth === "browser")) {
+    throw new CliError(`${info.kind} accounts do not take a secret`, {
+      hint: info.auth === "cli-login" ? "Log in with `davecode accounts login <id>` after adding the account." : "The browser profile holds the session."
+    });
+  }
+  if (info.kind === "openai-compatible") {
+    if (!flags.baseUrl) {
+      throw new CliError("openai-compatible accounts need --base-url", {
+        hint: `e.g. --base-url ${DEFAULT_COMPATIBLE_URL} for OpenRouter`
+      });
+    }
+  }
+  if (flags.baseUrl) {
+    const problem = validateUrl(flags.baseUrl);
+    if (problem) throw new CliError(`--base-url ${problem}`);
+  }
+  const create = {
+    provider: info.kind,
+    label: flags.label?.trim() || info.defaultLabel,
+    config: providerConfig(info, {
+      ...flags.baseUrl ? { baseUrl: flags.baseUrl } : {},
+      ...flags.model ? { models: flags.model } : {},
+      ...flags.defaultModel ? { defaultModel: flags.defaultModel } : {},
+      ...flags.binaryPath ? { binaryPath: flags.binaryPath } : {}
+    })
+  };
+  if (flags.priority !== void 0) create.priority = flags.priority;
+  if (flags.weight !== void 0) create.weight = flags.weight;
+  const limits = parseLimits(flags.limit);
+  if (Object.keys(limits).length > 0) create.limits = limits;
+  if (flags.disabled) create.enabled = false;
+  if (secret) create.secret = secret;
+  return create;
+}
+function uniqueLabel(base, existing) {
+  const taken = new Set(existing.map((a) => a.label.toLowerCase()));
+  if (!taken.has(base.toLowerCase())) return base;
+  for (let n = 2; ; n++) {
+    const candidate = `${base} ${n}`;
+    if (!taken.has(candidate.toLowerCase())) return candidate;
+  }
+}
+async function accountInteractively(flags, deps) {
+  const { prompter, say } = deps;
+  const warn = deps.warn ?? ((t) => t);
+  const kind = flags.provider ? requireProvider(flags.provider).kind : await prompter.select(
+    "Provider",
+    PROVIDERS.map((p) => ({ value: p.kind, label: p.name, hint: authHint(p.auth) })),
+    "anthropic"
+  );
+  const info = requireProvider(kind);
+  const policy = accountPolicy(info.kind, deps.config, deps.existing);
+  if (policy.blocked) throw new CliError(policy.blocked.message, { hint: policy.blocked.hint });
+  for (const warning of policy.warnings) {
+    say(warn(`! ${warning}`));
+    if (!await prompter.confirm("I understand the risk. Continue?", false)) return void 0;
+  }
+  const label = flags.label?.trim() || await prompter.text("Label", {
+    initial: uniqueLabel(info.defaultLabel, deps.existing),
+    validate: (v) => v.trim() ? void 0 : "a label is required"
+  });
+  const priority = flags.priority ?? Number(
+    await prompter.text("Priority (lower is tried first)", {
+      initial: "100",
+      validate: (v) => /^\d+$/.test(v.trim()) ? void 0 : "enter a non-negative integer"
+    })
+  );
+  let baseUrl = flags.baseUrl;
+  let models = flags.model;
+  if (info.kind === "openai-compatible") {
+    baseUrl ??= await prompter.text("Base URL", {
+      initial: DEFAULT_COMPATIBLE_URL,
+      validate: validateUrl
+    });
+    if (!models) {
+      const answer = await prompter.text("Models (comma-separated, empty to discover)", {
+        initial: ""
+      });
+      models = answer.split(",").map((m) => m.trim()).filter(Boolean);
+    }
+  }
+  let secret;
+  if (info.auth === "api-key" || info.auth === "optional-key") {
+    const optional = info.auth === "optional-key";
+    const answer = await prompter.secret(
+      optional ? "API key (optional, input hidden)" : `${info.name} key (input hidden)`,
+      { optional }
+    );
+    secret = answer.trim() || void 0;
+    if (!secret && !optional) throw new CliError(`${info.name} needs an API key`);
+  }
+  const create = {
+    provider: info.kind,
+    label: label.trim(),
+    priority,
+    config: providerConfig(info, {
+      ...baseUrl ? { baseUrl } : {},
+      ...models ? { models } : {},
+      ...flags.defaultModel ? { defaultModel: flags.defaultModel } : {},
+      ...flags.binaryPath ? { binaryPath: flags.binaryPath } : {}
+    })
+  };
+  if (flags.weight !== void 0) create.weight = flags.weight;
+  const limits = parseLimits(flags.limit);
+  if (Object.keys(limits).length > 0) create.limits = limits;
+  if (flags.disabled) create.enabled = false;
+  if (secret) create.secret = secret;
+  say("");
+  for (const line of describeCreate(create)) say(`  ${line}`);
+  say("");
+  if (!await prompter.confirm("Add this account?", true)) return void 0;
+  return create;
+}
+function authHint(auth) {
+  switch (auth) {
+    case "api-key":
+      return "API key";
+    case "optional-key":
+      return "base URL, optional key";
+    case "cli-login":
+      return "local CLI login, isolated per account";
+    default:
+      return "experimental, ToS risk";
+  }
+}
+function describeCreate(create) {
+  const lines = [
+    `provider  ${create.provider}`,
+    `label     ${create.label}`,
+    `priority  ${create.priority ?? 100}`
+  ];
+  const config = create.config ?? {};
+  if (typeof config.baseUrl === "string") lines.push(`base URL  ${config.baseUrl}`);
+  if (Array.isArray(config.models) && config.models.length > 0) {
+    lines.push(`models    ${config.models.join(", ")}`);
+  }
+  if (create.limits && Object.keys(create.limits).length > 0) {
+    lines.push(
+      `limits    ${Object.entries(create.limits).map(([k, v]) => `${k}=${v}`).join(" ")}`
+    );
+  }
+  if (create.secret !== void 0) lines.push("secret    set (stored encrypted)");
+  return lines;
+}
+
+// src/commands/accounts.ts
+async function backendFor(ctx, flags, deps) {
+  if (deps.backend) return deps.backend;
+  const projectRoot = await detectProjectRoot(ctx.cwd, ctx.home);
+  return openAccounts({
+    home: ctx.home,
+    env: ctx.env,
+    ...projectRoot ? { projectRoot } : {},
+    ...flags.local ? { local: true } : {}
+  });
+}
+async function withBackend(ctx, flags, deps, fn) {
+  const backend = await backendFor(ctx, flags, deps);
+  try {
+    return await fn(backend);
+  } finally {
+    if (!deps.backend) backend.close();
+  }
+}
+async function prompterFor(ctx, deps) {
+  if (deps.prompter) return deps.prompter;
+  const { createInkPrompter } = await import("./prompts-L37J72YW.js");
+  return createInkPrompter({ stdout: ctx.io.stdout, stdin: ctx.io.stdin, theme: ctx.theme });
+}
+function readAllStdin() {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve(data));
+    process.stdin.on("error", reject);
+  });
+}
+function statusText(theme, account) {
+  switch (account.status) {
+    case "active":
+      return theme.ok("active");
+    case "cooldown":
+      return theme.warn("cooldown");
+    case "error":
+      return theme.error("error");
+    default:
+      return theme.dim("disabled");
+  }
+}
+function detail(account) {
+  const config = account.config;
+  const parts = [];
+  if (typeof config.baseUrl === "string") parts.push(config.baseUrl);
+  if (Array.isArray(config.models) && config.models.length > 0) {
+    parts.push(config.models.slice(0, 3).join(", ") + (config.models.length > 3 ? ", \u2026" : ""));
+  }
+  if (typeof config.binaryPath === "string") parts.push(config.binaryPath);
+  return parts.join(" \xB7 ");
+}
+function renderAccountList(theme, accounts, columns) {
+  const cols = [
+    { header: "ID" },
+    { header: "LABEL" },
+    { header: "PROVIDER" },
+    { header: "STATUS" },
+    { header: "PRI", align: "right", drop: 2 },
+    { header: "WEIGHT", align: "right", drop: 3 },
+    { header: "DETAILS", drop: 4 }
+  ];
+  const rows = accounts.map((a) => [
+    theme.accent(a.id),
+    truncate(a.label, 28),
+    a.provider,
+    statusText(theme, a),
+    String(a.priority),
+    String(a.weight),
+    theme.dim(truncate(detail(a), 40))
+  ]);
+  return table(theme, cols, rows, columns);
+}
+async function accountsList(ctx, flags = {}, deps = {}) {
+  return withBackend(ctx, flags, deps, async (backend) => {
+    const accounts = await backend.list();
+    if (ctx.json) {
+      printJson(ctx, { source: backend.kind, accounts });
+      return EXIT.ok;
+    }
+    if (accounts.length === 0) {
+      ctx.out(ctx.theme.dim("No accounts yet."));
+      ctx.out(`Add one with ${ctx.theme.accent("davecode accounts add")}.`);
+      return EXIT.ok;
+    }
+    for (const line of renderAccountList(ctx.theme, accounts, ctx.columns)) ctx.out(line);
+    ctx.out();
+    ctx.out(
+      ctx.theme.dim(backend.kind === "gateway" ? "source: running gateway" : "source: local state")
+    );
+    return EXIT.ok;
+  });
+}
+async function accountsAdd(ctx, flags, deps = {}) {
+  return withBackend(ctx, flags, deps, async (backend) => {
+    const existing = await backend.list();
+    const interactive = ctx.interactive && !flags.yes && !flags.secretStdin;
+    const { theme, errTheme } = ctx;
+    let create;
+    if (interactive) {
+      try {
+        create = await accountInteractively(flags, {
+          prompter: await prompterFor(ctx, deps),
+          config: backend.config,
+          existing,
+          say: (line) => ctx.out(line),
+          warn: theme.warn
+        });
+      } catch (err) {
+        if (err instanceof PromptCancelledError) {
+          ctx.err(errTheme.dim("Cancelled."));
+          return EXIT.failure;
+        }
+        throw err;
+      }
+      if (!create) {
+        ctx.err(errTheme.dim("Nothing added."));
+        return EXIT.failure;
+      }
+    } else {
+      create = await accountFromFlags(flags, {
+        env: ctx.env,
+        readStdin: deps.readStdin ?? readAllStdin
+      });
+      const policy = accountPolicy(create.provider, backend.config, existing);
+      if (policy.blocked) {
+        throw new CliError(policy.blocked.message, { hint: policy.blocked.hint });
+      }
+      for (const warning of policy.warnings) {
+        ctx.err(errTheme.warn(`${errTheme.glyph.warn} ${warning}`));
+      }
+      if (flags.secret !== void 0) {
+        ctx.err(
+          errTheme.dim(
+            "Note: --secret is visible in shell history and process lists; prefer --secret-env or --secret-stdin."
+          )
+        );
+      }
+    }
+    const account = await backend.create(create);
+    if (ctx.json) {
+      printJson(ctx, { account });
+      return EXIT.ok;
+    }
+    ctx.out(
+      `${theme.ok(theme.glyph.ok)} Added ${theme.bold(account.label)} ${theme.dim(`(${account.id}, ${account.provider})`)}`
+    );
+    if (!interactive) {
+      for (const line of describeCreate(create)) ctx.out(theme.dim(`  ${line}`));
+    }
+    const info = providerInfo(account.provider);
+    if (info?.auth === "cli-login") {
+      const loginNow = interactive && flags.login !== false && await (await prompterFor(ctx, deps)).confirm(`Log in to ${info.binary} for this account now?`, true);
+      if (loginNow) return accountsLogin(ctx, account.id, [], flags, { ...deps, backend });
+      ctx.out(
+        theme.dim(`Next: log in with ${theme.accent(`davecode accounts login ${account.id}`)}`)
+      );
+    }
+    return EXIT.ok;
+  });
+}
+async function accountsRemove(ctx, ref, flags, deps = {}) {
+  return withBackend(ctx, flags, deps, async (backend) => {
+    const account = await resolveAccount(backend, ref);
+    if (!flags.yes) {
+      if (!ctx.interactive) {
+        throw new CliError(`Refusing to remove ${account.id} without confirmation`, {
+          hint: "Pass --yes to remove it non-interactively."
+        });
+      }
+      const ok = await (await prompterFor(ctx, deps)).confirm(`Remove ${account.label} (${account.id}) and its sandbox?`, false).catch((err) => {
+        if (err instanceof PromptCancelledError) return false;
+        throw err;
+      });
+      if (!ok) {
+        ctx.err(ctx.errTheme.dim("Nothing removed."));
+        return EXIT.failure;
+      }
+    }
+    await backend.remove(account.id);
+    if (ctx.json) printJson(ctx, { removed: account.id });
+    else ctx.out(`${ctx.theme.ok(ctx.theme.glyph.ok)} Removed ${account.label} (${account.id})`);
+    return EXIT.ok;
+  });
+}
+async function accountsSetEnabled(ctx, ref, enabled, flags = {}, deps = {}) {
+  return withBackend(ctx, flags, deps, async (backend) => {
+    const account = await resolveAccount(backend, ref);
+    const updated = await backend.update(account.id, { enabled });
+    if (ctx.json) printJson(ctx, { account: updated });
+    else {
+      ctx.out(
+        `${ctx.theme.ok(ctx.theme.glyph.ok)} ${updated.label} is now ${enabled ? "enabled" : "disabled"} ${ctx.theme.dim(`(${updated.status})`)}`
+      );
+    }
+    return EXIT.ok;
+  });
+}
+function describeSubscription(subscription) {
+  if (!subscription) return "no plan recorded";
+  const parts = [];
+  if (subscription.plan) parts.push(subscription.plan);
+  if (subscription.price) {
+    const { amount, currency, period } = subscription.price;
+    parts.push(`${amount} ${currency}/${period}`);
+  }
+  if (subscription.paidAt) parts.push(`paid ${subscription.paidAt}`);
+  if (subscription.renewsAt) parts.push(`renews ${subscription.renewsAt}`);
+  if (subscription.notes) parts.push(subscription.notes);
+  return parts.length > 0 ? parts.join(" \xB7 ") : "no plan recorded";
+}
+function subscriptionFromFlags(existing, flags) {
+  const next = { ...existing };
+  if (flags.plan !== void 0) next.plan = flags.plan;
+  if (flags.paid !== void 0) next.paidAt = flags.paid;
+  if (flags.renews !== void 0) next.renewsAt = flags.renews;
+  if (flags.notes !== void 0) next.notes = flags.notes;
+  if (flags.price !== void 0 || flags.currency !== void 0 || flags.period !== void 0) {
+    const amount = flags.price !== void 0 ? Number(flags.price) : existing?.price?.amount;
+    if (amount === void 0 || !Number.isFinite(amount)) {
+      throw new CliError("--price needs a number, e.g. --price 20", {
+        hint: "Set the amount with --price, and optionally --currency USD --period month."
+      });
+    }
+    const period = flags.period ?? existing?.price?.period ?? "month";
+    if (period !== "month" && period !== "year") {
+      throw new CliError('--period must be "month" or "year"');
+    }
+    next.price = { amount, currency: flags.currency ?? existing?.price?.currency ?? "USD", period };
+  }
+  return next;
+}
+async function accountsPlan(ctx, ref, flags = {}, deps = {}) {
+  return withBackend(ctx, flags, deps, async (backend) => {
+    const account = await resolveAccount(backend, ref);
+    const { theme } = ctx;
+    const changes = ["plan", "paid", "renews", "price", "currency", "period", "notes"];
+    const editing = flags.clear || changes.some((key) => flags[key] !== void 0);
+    if (!editing) {
+      if (ctx.json)
+        printJson(ctx, { account: account.id, subscription: account.subscription ?? null });
+      else ctx.out(`${theme.bold(account.label)}: ${describeSubscription(account.subscription)}`);
+      return EXIT.ok;
+    }
+    const subscription = flags.clear ? null : subscriptionFromFlags(account.subscription, flags);
+    const updated = await backend.update(account.id, { subscription });
+    if (ctx.json) printJson(ctx, { account: updated });
+    else {
+      ctx.out(
+        `${theme.ok(theme.glyph.ok)} ${updated.label}: ${describeSubscription(updated.subscription)}`
+      );
+    }
+    return EXIT.ok;
+  });
+}
+function loginArgs(provider) {
+  return CLI_LOGINS[provider]?.loginArgs ?? [];
+}
+function waitForEnter() {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question("Press Enter to close this window.", () => {
+      rl.close();
+      resolve();
+    });
+    rl.once("close", resolve);
+  });
+}
+function describeConnection(theme, connection) {
+  const label = {
+    connected: theme.ok(`${theme.glyph.ok} connected`),
+    not_connected: theme.warn(`${theme.glyph.warn} not connected`),
+    unknown: theme.dim("? unknown")
+  };
+  return `${label[connection.status]}${connection.detail ? theme.dim(` \u2014 ${connection.detail}`) : ""}`;
+}
+async function accountsLogin(ctx, ref, extraArgs = [], flags = {}, deps = {}) {
+  if (!flags.hold) return runLogin(ctx, ref, extraArgs, flags, deps);
+  try {
+    return await runLogin(ctx, ref, extraArgs, flags, deps);
+  } catch (err) {
+    ctx.err(ctx.errTheme.warn(err instanceof Error ? err.message : String(err)));
+    return EXIT.failure;
+  } finally {
+    await (deps.waitForEnter ?? waitForEnter)();
+  }
+}
+function runLogin(ctx, ref, extraArgs, flags, deps) {
+  return withBackend(ctx, flags, deps, async (backend) => {
+    const account = await resolveAccount(backend, ref);
+    const spec = CLI_LOGINS[account.provider];
+    if (!spec) {
+      const info = providerInfo(account.provider);
+      throw new CliError(`${account.provider} accounts do not use a CLI login`, {
+        hint: info?.auth === "api-key" || info?.auth === "optional-key" ? `Rotate the key with: davecode accounts add \u2026 or PATCH /api/accounts/${account.id}` : void 0
+      });
+    }
+    const binary = cliBinaryFor(account) ?? spec.binary;
+    const resolved = which(binary, ctx.env);
+    if (!resolved) {
+      throw new CliError(`Cannot find \`${binary}\` on PATH`, { hint: spec.installHint });
+    }
+    const sandboxes = new SandboxManager(globalPaths(ctx.home).sandboxes);
+    const dir = sandboxes.prepare(account);
+    const isolation = loginEnv(account, sandboxes);
+    const env = { ...ctx.env, ...isolation };
+    const [variable] = Object.keys(isolation);
+    const { theme } = ctx;
+    ctx.out(
+      `${theme.accent(theme.glyph.arrow)} Logging in ${theme.bold(account.label)} ${theme.dim(`(${account.id})`)}`
+    );
+    ctx.out(theme.dim(`  ${variable}=${dir}`));
+    ctx.out(theme.dim(`  ${spec.instructions}`));
+    ctx.out(theme.dim("  DaveCode never sees your password; the vendor CLI keeps the login."));
+    ctx.out();
+    const args = extraArgs.length > 0 ? extraArgs : spec.loginArgs;
+    const exit = await spawnInteractive(resolved, args, {
+      env,
+      cwd: dir,
+      ...deps.spawn ? { spawn: deps.spawn } : {}
+    });
+    ctx.out();
+    if (exit !== 0) {
+      ctx.err(ctx.errTheme.warn(`${binary} exited with code ${exit}`));
+      return exit;
+    }
+    if (account.status === "error" && account.enabled) {
+      await backend.update(account.id, { enabled: true });
+    }
+    const connection = await backend.connection(account.id).catch(() => void 0);
+    if (connection) ctx.out(`  ${describeConnection(theme, connection)}`);
+    ctx.out(
+      `${theme.ok(theme.glyph.ok)} ${account.label} is ready. Its login lives only in ${dir}`
+    );
+    return EXIT.ok;
+  });
+}
+async function accountsConnect(ctx, ref, flags = {}, deps = {}) {
+  const { account, connection } = await withBackend(ctx, flags, deps, async (backend) => {
+    const account2 = await resolveAccount(backend, ref);
+    return { account: account2, connection: await backend.connection(account2.id) };
+  });
+  if (ctx.json) {
+    printJson(ctx, { connection });
+    return connection.status === "connected" || flags.check ? EXIT.ok : EXIT.failure;
+  }
+  const { theme } = ctx;
+  ctx.out(`${theme.bold(account.label)} ${theme.dim(`(${account.id}, ${account.provider})`)}`);
+  ctx.out(`  ${describeConnection(theme, connection)}`);
+  if (flags.check || connection.status === "connected") return EXIT.ok;
+  if (connection.method === "api-key") {
+    ctx.out(
+      theme.dim(
+        `  Store a key in the dashboard (Accounts \u2192 ${account.label}) or re-add the account with --secret-env.`
+      )
+    );
+    return EXIT.failure;
+  }
+  if (connection.method !== "cli-login") return EXIT.failure;
+  ctx.out();
+  return accountsLogin(ctx, account.id, [], flags, deps);
+}
+export {
+  accountsAdd,
+  accountsConnect,
+  accountsList,
+  accountsLogin,
+  accountsPlan,
+  accountsRemove,
+  accountsSetEnabled,
+  describeConnection,
+  describeSubscription,
+  loginArgs,
+  renderAccountList,
+  subscriptionFromFlags
+};
+//# sourceMappingURL=accounts-MTMGYKEP.js.map