@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/commands/lanes-accounts.js

@@ -0,0 +1,595 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { buildOutpostBalanceMoveCommand, dispatchErrorMessage } from "../lib/lanes/outpost-dispatch.js";
+import { BALANCE_MOVABLE_STATES, accountLoadsForReport, planClaudeBalanceMoves, selectClaudeAccount } from "../lib/lanes/claude-balance.js";
+import { CompanySelectionError } from "../utils/company-selection-error.js";
+import { effectiveAccountHome } from "../lib/lanes/account-home.js";
+import { AccountResolutionError, DEFAULT_ACCOUNT_HOMES, LANE_PROVIDERS, PROVIDER_HOME_ENV, accountStatus, canonicalizeHome, installDrainHook, isLanesError, listAccountStatuses, loadLanesConfig, parseLaneProvider, readLane, writeLanesConfig } from "../lib/lanes/index.js";
+import { assertUniqueAccountHomes, providerCompactAfterMs } from "../lib/lanes/config.js";
+import { resolveLaneEffort } from "../lib/lanes/effort.js";
+import { LanesError } from "../lib/lanes/errors.js";
+import { accountQuotaView, clearAccountQuota, loadQuotaState } from "../lib/lanes/quota.js";
+import { resolveLaneModel } from "../lib/lanes/spawn.js";
+export function createLaneAccountsHandlers(deps) {
+    const { automaticBalanceMoveHistoryReason, ensureDir, laneWithRecoveredProviderSession, loadClaudeBalanceHostSnapshots, parseRemoteJson, prepareAccountMove, printJson, reconcileHostFromCtx, resolveCallerPath } = deps;
+    const VENDOR_LOGIN = {
+        claude: { command: "claude", args: ["auth", "login"] },
+        codex: { command: "codex", args: ["login"] },
+        grok: { command: "grok", args: ["login"] },
+    };
+    async function resolveSelectedAccountHomeCompany(ctx, selector) {
+        const company = await ctx.resolveActiveCompany(selector);
+        if (!company) {
+            throw new CompanySelectionError(`No unique active company membership for ${selector}. Pass an active company UID with --company.`);
+        }
+        return company;
+    }
+    function copyHookRails(fromHome, toHome) {
+        const src = path.join(fromHome, "hooks");
+        if (!fs.existsSync(src))
+            return false;
+        fs.cpSync(src, path.join(toHome, "hooks"), { recursive: true });
+        return true;
+    }
+    function railsPresent(home) {
+        return fs.existsSync(path.join(home, "hooks"));
+    }
+    async function applyClaudeBalanceMove(ctx, suggestion) {
+        const currentHost = reconcileHostFromCtx(ctx);
+        const suggestionRunsHere = suggestion.host.kind === "outpost"
+            ? currentHost.outpostId === suggestion.host.id
+            : currentHost.outpostId === null && currentHost.hostname === suggestion.host.id;
+        if (suggestion.host.kind === "outpost" && !suggestionRunsHere) {
+            let result;
+            try {
+                result = await ctx.dispatchOutpostExec({
+                    outpostId: suggestion.host.id,
+                    command: buildOutpostBalanceMoveCommand({
+                        laneId: suggestion.lane_id,
+                        account: suggestion.to,
+                        fromAccount: suggestion.from,
+                        expectedState: suggestion.state,
+                    }),
+                    timeoutSeconds: 120,
+                    waitMs: 120_000,
+                });
+            }
+            catch (err) {
+                throw new LanesError("claude_account_balance_move_failed", `Could not move lane ${suggestion.lane_id} on Outpost ${suggestion.host.id}: ${dispatchErrorMessage(err)}`, { lane_id: suggestion.lane_id, host: suggestion.host, account: suggestion.to });
+            }
+            if (result.done !== true || result.status !== "Success" || result.exitCode !== 0) {
+                throw new LanesError("claude_account_balance_move_failed", `Outpost ${suggestion.host.id} did not confirm the account move for lane ${suggestion.lane_id}`, { lane_id: suggestion.lane_id, host: suggestion.host, account: suggestion.to, status: result.status, exit_code: result.exitCode });
+            }
+            const remote = parseRemoteJson(result.stdout, "Claude account balance move");
+            if (remote?.ok !== true || remote.action !== "balance-move-target" ||
+                remote.lane_id !== suggestion.lane_id || remote.from !== suggestion.from ||
+                remote.account !== suggestion.to ||
+                remote.state !== suggestion.state) {
+                throw new LanesError("claude_account_balance_move_unconfirmed", `Outpost ${suggestion.host.id} returned an invalid account-move result`, {
+                    lane_id: suggestion.lane_id,
+                    host: suggestion.host,
+                    account: suggestion.to,
+                });
+            }
+            return { lane_id: suggestion.lane_id, host: suggestion.host, from: suggestion.from, to: suggestion.to, state: suggestion.state };
+        }
+        const lane = laneWithRecoveredProviderSession(ctx.hqRoot(), readLane(ctx.hqRoot(), suggestion.lane_id));
+        if (lane.state === "running") {
+            throw new LanesError("lane_running", `Lane ${lane.lane_id} is running; balance never moves a running turn`, {
+                lane_id: lane.lane_id,
+                state: lane.state,
+            });
+        }
+        if (lane.host.kind !== suggestion.host.kind || lane.host.id !== suggestion.host.id ||
+            lane.account !== suggestion.from || lane.state !== suggestion.state) {
+            throw new LanesError("claude_account_balance_lane_changed", `Lane ${lane.lane_id} changed after balance was calculated`, {
+                lane_id: lane.lane_id,
+                host: lane.host,
+                account: lane.account ?? null,
+            });
+        }
+        if (!BALANCE_MOVABLE_STATES.includes(lane.state)) {
+            throw new LanesError("claude_account_balance_state_not_movable", `Lane ${lane.lane_id} is no longer between turns`, {
+                lane_id: lane.lane_id,
+                state: lane.state,
+            });
+        }
+        const moved = await prepareAccountMove(ctx, lane, {
+            account: suggestion.to,
+            cliModel: undefined,
+            accountHistoryReason: automaticBalanceMoveHistoryReason(ctx, lane),
+            deferTurnStart: true,
+        });
+        return { lane_id: moved.lane.lane_id, host: moved.lane.host, from: moved.from ?? suggestion.from, to: moved.to, state: moved.lane.state };
+    }
+    async function runAccountsList(ctx, opts) {
+        const hqRoot = ctx.hqRoot();
+        const config = loadLanesConfig(hqRoot);
+        const providers = opts.provider
+            ? [parseLaneProvider(opts.provider)]
+            : [...LANE_PROVIDERS];
+        // model and effort are what a spawn on each account would start from
+        // (spec: --model/--effort, then the account, then the provider).
+        const quota = loadQuotaState(hqRoot);
+        const accounts = providers.flatMap((provider) => listAccountStatuses(provider, config, {
+            existsSync: ctx.existsSync,
+            hostname: ctx.hostname(),
+            probe: ctx.probeProvider,
+            env: ctx.env,
+        }).map((status) => {
+            const accountCfg = config.providers[provider].accounts[status.id];
+            const model = resolveLaneModel({
+                accountModel: accountCfg?.model,
+                providerModel: config.providers[provider].model,
+            });
+            const effort = resolveLaneEffort({
+                accountEffort: accountCfg?.effort,
+                providerEffort: config.providers[provider].effort,
+                model,
+            });
+            return {
+                ...status,
+                effective_home: status.home,
+                ...(status.auth_state === "home_missing" ? {
+                    error: "home_missing",
+                    fix_command: `hq lanes accounts set-home ${provider} ${status.id} <host-home>`,
+                } : {}),
+                model: accountCfg?.model ?? null,
+                effort: accountCfg?.effort ?? null,
+                effective_model: model ?? null,
+                effective_effort: effort.effort ?? null,
+                effective_effort_source: effort.source,
+                ...accountQuotaView(quota, provider, status.id),
+            };
+        }));
+        const providerDefaults = providers.map((provider) => ({
+            provider,
+            model: config.providers[provider].model ?? null,
+            effort: config.providers[provider].effort ?? null,
+            compact_after_ms: providerCompactAfterMs(config.providers[provider]),
+        }));
+        printJson({
+            ok: true,
+            action: "accounts.list",
+            providers: providerDefaults,
+            accounts,
+        });
+    }
+    async function runAccountsBalance(ctx, opts) {
+        const provider = parseLaneProvider(opts.provider ?? "");
+        if (provider !== "claude") {
+            throw new LanesError("claude_account_balance_provider_unsupported", "Account balance is available only for --provider claude", {
+                provider,
+                accepted: ["claude"],
+            });
+        }
+        const hqRoot = ctx.hqRoot();
+        const config = loadLanesConfig(hqRoot);
+        const quotaState = loadQuotaState(hqRoot);
+        const loaded = await loadClaudeBalanceHostSnapshots(ctx, hqRoot, config);
+        // Retain the established response field for clients; balancing is now
+        // unconditional, so this compatibility value is always true.
+        const balanceGateEnabled = true;
+        const recentUsageEnabled = await deps.readClaudeAccountBalanceSignalsEnabled(ctx);
+        const loads = accountLoadsForReport({ hosts: loaded.snapshots, config, quotaState });
+        const suggestions = planClaudeBalanceMoves({ hosts: loaded.snapshots, config });
+        const selections = loaded.snapshots.map((host) => {
+            try {
+                const selection = selectClaudeAccount({
+                    hosts: loaded.snapshots,
+                    targetHost: host.capacity.host,
+                    config,
+                    quotaState,
+                    recentUsageEnabled,
+                    now: ctx.now(),
+                    unavailableHosts: loaded.unavailableHosts,
+                });
+                return {
+                    target_host: host.capacity.host,
+                    account: selection.account,
+                    signal: selection.signal,
+                    skipped_accounts: selection.skipped_accounts,
+                };
+            }
+            catch (err) {
+                return {
+                    target_host: host.capacity.host,
+                    error: isLanesError(err) ? err.error : "claude_account_balance_selection_failed",
+                    message: dispatchErrorMessage(err),
+                };
+            }
+        });
+        const accounts = Object.keys(config.providers.claude.accounts).sort().map((account) => {
+            const load = loads.find((row) => row.account === account);
+            const currentStatus = loaded.snapshots[0]?.capacity.providers.claude.accounts[account];
+            const currentHomeMissing = config.providers.claude.accounts[account]?.enabled === true &&
+                currentStatus?.auth_state === "home_missing";
+            return {
+                account,
+                enabled: config.providers.claude.accounts[account]?.enabled === true,
+                live_lanes: load?.live_lanes ?? 0,
+                counts_complete: load?.counts_complete ?? false,
+                ...(load ? { recent_usage_at: load.recent_usage_at } : {}),
+                ...(currentHomeMissing ? {
+                    error: "home_missing",
+                    fix_command: `hq lanes accounts set-home claude ${account} <host-home>`,
+                } : {}),
+                hosts: loaded.snapshots.map((host) => {
+                    const accountStatus = host.capacity.providers.claude.accounts[account];
+                    const accountLoad = load?.hosts.find((row) => row.host.kind === host.capacity.host.kind && row.host.id === host.capacity.host.id);
+                    return {
+                        host: host.capacity.host,
+                        enabled: accountStatus?.enabled ?? false,
+                        logged_in: accountStatus?.logged_in ?? null,
+                        ...(accountStatus?.auth_state !== undefined ? { auth_state: accountStatus.auth_state } : {}),
+                        ...(accountStatus?.auth_state === "home_missing" ? {
+                            error: "home_missing",
+                            fix_command: `hq lanes accounts set-home claude ${account} <host-home>`,
+                        } : {}),
+                        live_lanes: accountLoad?.live_lanes ?? null,
+                        lane_counts: accountLoad?.lane_counts ?? { running: null, queued: null, awaiting_input: null },
+                        count_source: accountLoad?.count_source ?? "unavailable",
+                        usage: accountStatus?.usage ?? null,
+                    };
+                }),
+            };
+        });
+        const moved = [];
+        const skipped = [];
+        if (opts.apply) {
+            for (const suggestion of suggestions) {
+                if (!suggestion.apply) {
+                    skipped.push({
+                        lane_id: suggestion.lane_id,
+                        host: suggestion.host,
+                        from: suggestion.from,
+                        to: suggestion.to,
+                        reason: suggestion.skip_reason ?? "not_movable",
+                    });
+                    continue;
+                }
+                try {
+                    moved.push(await applyClaudeBalanceMove(ctx, suggestion));
+                }
+                catch (err) {
+                    skipped.push({
+                        lane_id: suggestion.lane_id,
+                        host: suggestion.host,
+                        from: suggestion.from,
+                        to: suggestion.to,
+                        reason: isLanesError(err) ? `${err.error}: ${err.message}` : dispatchErrorMessage(err),
+                    });
+                }
+            }
+        }
+        printJson({
+            ok: true,
+            action: "accounts.balance",
+            provider: "claude",
+            balance_gate_enabled: balanceGateEnabled,
+            accounts,
+            selections,
+            unavailable_hosts: loaded.unavailableHosts,
+            suggestions,
+            ...(opts.apply ? { moved, skipped } : {}),
+        });
+        const currentHostMissing = Object.entries(config.providers.claude.accounts).some(([account, accountConfig]) => accountConfig.enabled &&
+            loaded.snapshots[0]?.capacity.providers.claude.accounts[account]?.auth_state === "home_missing");
+        if (currentHostMissing)
+            process.exitCode = 1;
+    }
+    async function runAccountsLogin(ctx, providerRaw, accountId, opts) {
+        const callerCwd = ctx.callerCwd();
+        const hqRoot = ctx.hqRoot();
+        const provider = parseLaneProvider(providerRaw);
+        const config = loadLanesConfig(hqRoot);
+        const id = accountId.trim();
+        if (!id) {
+            throw new LanesError("invalid_account", "account-id must be non-empty", {});
+        }
+        if (opts.deviceAuth && provider !== "codex") {
+            throw new LanesError("device_auth_unsupported", "--device-auth is supported only for codex account login", { provider });
+        }
+        const registeredAccount = config.providers[provider].accounts[id];
+        const hostname = ctx.hostname().trim();
+        if (!hostname) {
+            throw new LanesError("host_identity_unknown", "Cannot resolve this host's hostname for account login", {});
+        }
+        const requestedHome = opts.home?.trim();
+        if (opts.home !== undefined && !requestedHome) {
+            throw new LanesError("invalid_account_home", "--home must be a non-empty path", { provider, account: id });
+        }
+        if (opts.company !== undefined) {
+            await resolveSelectedAccountHomeCompany(ctx, opts.company);
+        }
+        if (process.platform === "linux" &&
+            requestedHome === undefined &&
+            registeredAccount !== undefined &&
+            effectiveAccountHome(registeredAccount, hostname).source !== "host") {
+            throw new LanesError("account_host_home_required", `Account ${id} for ${provider} has no home for this Linux host; pass --home <host-home> to store a host-specific home`, { provider, account: id, hostname });
+        }
+        const homeRaw = requestedHome ??
+            (registeredAccount !== undefined
+                ? effectiveAccountHome(registeredAccount, hostname).home
+                : id === "a"
+                    ? DEFAULT_ACCOUNT_HOMES[provider]
+                    : `~/.${provider}-${id}`);
+        const homeResolved = homeRaw.startsWith("~") || path.isAbsolute(homeRaw)
+            ? homeRaw
+            : resolveCallerPath(callerCwd, homeRaw);
+        const home = canonicalizeHome(homeResolved, {
+            homedir: ctx.homedir,
+            realpathSync: (p) => fs.realpathSync(p),
+            existsSync: (p) => fs.existsSync(p),
+        });
+        const nextAccount = registeredAccount === undefined
+            ? process.platform === "linux"
+                ? {
+                    home: id === "a" ? DEFAULT_ACCOUNT_HOMES[provider] : `~/.${provider}-${id}`,
+                    hosts: { [hostname]: { home } },
+                    enabled: true,
+                }
+                : { home, enabled: true }
+            : { ...registeredAccount, enabled: true };
+        if (registeredAccount !== undefined && requestedHome !== undefined) {
+            if (process.platform === "linux") {
+                nextAccount.hosts = {
+                    ...(registeredAccount.hosts ?? {}),
+                    [hostname]: { home },
+                };
+            }
+            else if (home === registeredAccount.home) {
+                if (nextAccount.hosts !== undefined) {
+                    delete nextAccount.hosts[hostname];
+                    if (Object.keys(nextAccount.hosts).length === 0)
+                        delete nextAccount.hosts;
+                }
+            }
+            else {
+                nextAccount.hosts = {
+                    ...(registeredAccount.hosts ?? {}),
+                    [hostname]: { home },
+                };
+            }
+        }
+        delete nextAccount.disabled_reason;
+        assertUniqueAccountHomes(provider, {
+            ...config.providers[provider].accounts,
+            [id]: nextAccount,
+        });
+        ensureDir(home);
+        const defaultId = config.providers[provider].default_account;
+        const defaultAccount = defaultId !== undefined
+            ? config.providers[provider].accounts[defaultId]
+            : Object.values(config.providers[provider].accounts).find((account) => account.enabled);
+        const defaultHome = (defaultAccount !== undefined
+            ? effectiveAccountHome(defaultAccount, hostname).home
+            : undefined) ??
+            canonicalizeHome(DEFAULT_ACCOUNT_HOMES[provider], {
+                homedir: ctx.homedir,
+                realpathSync: (p) => fs.realpathSync(p),
+                existsSync: (p) => fs.existsSync(p),
+            });
+        const copied = defaultHome !== home ? copyHookRails(defaultHome, home) : railsPresent(home);
+        installDrainHook(provider, home);
+        const envVar = PROVIDER_HOME_ENV[provider];
+        const login = VENDOR_LOGIN[provider];
+        const loginArgs = provider === "codex" && opts.deviceAuth
+            ? [...login.args, "--device-auth"]
+            : login.args;
+        const result = await ctx.spawnLogin({
+            command: login.command,
+            args: loginArgs,
+            env: { ...ctx.env, [envVar]: home },
+            cwd: home,
+        });
+        if (result.status !== 0) {
+            throw new LanesError("login_failed", `${login.command} ${loginArgs.join(" ")} exited ${result.status}`, { provider, account: id, status: result.status });
+        }
+        const grokNeedsRails = provider === "grok";
+        if ((grokNeedsRails || copied) && !railsPresent(home)) {
+            throw new LanesError("rails_missing", `Hook rails are missing under ${home}; account not enabled`, { provider, account: id, home });
+        }
+        config.providers[provider].accounts[id] = nextAccount;
+        const status = accountStatus(provider, id, config, {
+            existsSync: ctx.existsSync,
+            hostname,
+            probe: ctx.probeProvider,
+            env: ctx.env,
+        });
+        if (status.logged_in !== true) {
+            throw new LanesError(status.logged_in === false ? "account_not_logged_in" : "account_login_status_unknown", status.logged_in === false
+                ? `Account ${id} for ${provider} is not logged in`
+                : `Could not verify that account ${id} for ${provider} is logged in`, { provider, account: id, home });
+        }
+        writeLanesConfig(hqRoot, config);
+        printJson({ ok: true, action: "accounts.login", account: status });
+    }
+    async function runAccountsSetHome(ctx, providerRaw, accountIdRaw, homeRaw, opts) {
+        if (opts.company !== undefined)
+            await resolveSelectedAccountHomeCompany(ctx, opts.company);
+        const callerCwd = ctx.callerCwd();
+        const hqRoot = ctx.hqRoot();
+        const provider = parseLaneProvider(providerRaw);
+        const id = accountIdRaw.trim();
+        if (!id) {
+            throw new AccountResolutionError("unknown_account", "account-id must be non-empty", {
+                provider,
+                account: accountIdRaw,
+                enabled: [],
+            });
+        }
+        const hostname = opts.host === undefined ? ctx.hostname().trim() : opts.host.trim();
+        if (!hostname || (opts.host !== undefined && hostname !== opts.host)) {
+            throw new LanesError("invalid_host", "--host must be a non-empty hostname without surrounding whitespace", {
+                host: opts.host ?? "",
+            });
+        }
+        if (!homeRaw.trim()) {
+            throw new LanesError("invalid_account_home", "home path must be a non-empty path", {
+                provider,
+                account: id,
+            });
+        }
+        const config = loadLanesConfig(hqRoot);
+        const account = config.providers[provider].accounts[id];
+        if (account === undefined) {
+            throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(id)} for ${provider}`, {
+                provider,
+                account: id,
+                enabled: Object.keys(config.providers[provider].accounts).filter((key) => config.providers[provider].accounts[key]?.enabled),
+            });
+        }
+        const homePath = homeRaw.trim();
+        const isCurrentHost = hostname === ctx.hostname().trim();
+        let home;
+        if (isCurrentHost) {
+            const homeResolved = homePath.startsWith("~") || path.isAbsolute(homePath)
+                ? homePath
+                : resolveCallerPath(callerCwd, homePath);
+            home = canonicalizeHome(homeResolved, {
+                homedir: ctx.homedir,
+                realpathSync: (p) => fs.realpathSync(p),
+                existsSync: (p) => fs.existsSync(p),
+            });
+        }
+        else if (homePath === "~" || homePath.startsWith("~/")) {
+            home = homePath;
+        }
+        else if (path.isAbsolute(homePath)) {
+            home = path.normalize(homePath);
+        }
+        else {
+            throw new LanesError("invalid_remote_account_home", "A home for another host must be an absolute path or start with ~/", { provider, account: id, hostname, home: homePath });
+        }
+        for (const [otherId, other] of Object.entries(config.providers[provider].accounts)) {
+            if (otherId !== id && effectiveAccountHome(other, hostname).home === home) {
+                throw new LanesError("duplicate_account_home", `Home ${home} is already registered as ${provider} account ${otherId} on host ${hostname}`, { provider, accounts: [otherId, id], home, hostname });
+            }
+        }
+        if (home === account.home) {
+            if (account.hosts !== undefined) {
+                delete account.hosts[hostname];
+                if (Object.keys(account.hosts).length === 0)
+                    delete account.hosts;
+            }
+        }
+        else {
+            const hosts = Object.assign(Object.create(null), account.hosts ?? {});
+            hosts[hostname] = { home };
+            account.hosts = hosts;
+        }
+        assertUniqueAccountHomes(provider, config.providers[provider].accounts);
+        writeLanesConfig(hqRoot, config);
+        printJson({
+            ok: true,
+            action: "accounts.set-home",
+            provider,
+            account: id,
+            hostname,
+            home,
+            home_source: home === account.home ? "default" : "host",
+        });
+    }
+    async function runAccountsClearQuota(ctx, providerRaw, accountIdRaw, opts) {
+        const provider = parseLaneProvider(providerRaw);
+        const account = accountIdRaw.trim();
+        if (!account) {
+            throw new AccountResolutionError("unknown_account", "account-id must be non-empty", { provider, account: accountIdRaw, enabled: [] });
+        }
+        const model = opts.model?.trim();
+        if (opts.model !== undefined && !model) {
+            throw new LanesError("invalid_model", "--model must be non-empty", {
+                provider,
+                account,
+            });
+        }
+        const cleared = clearAccountQuota(ctx.hqRoot(), provider, account, model === undefined ? {} : { model });
+        printJson({
+            ok: true,
+            action: "accounts.clear-quota",
+            provider,
+            account,
+            all_models_quota_reset_at: cleared.all_models_quota_reset_at,
+            model_quota_resets: cleared.model_quota_resets,
+        });
+    }
+    async function runAccountsEnable(ctx, providerRaw, accountId) {
+        const hqRoot = ctx.hqRoot();
+        const provider = parseLaneProvider(providerRaw);
+        const config = loadLanesConfig(hqRoot);
+        const account = config.providers[provider].accounts[accountId];
+        if (!account) {
+            throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(accountId)} for ${provider}`, {
+                provider,
+                account: accountId,
+                enabled: Object.entries(config.providers[provider].accounts)
+                    .filter(([, a]) => a.enabled)
+                    .map(([id]) => id),
+            });
+        }
+        const status = accountStatus(provider, accountId, config, {
+            existsSync: ctx.existsSync,
+            hostname: ctx.hostname(),
+            probe: ctx.probeProvider,
+            env: ctx.env,
+        });
+        if (status.logged_in !== true) {
+            throw new LanesError(status.logged_in === false ? "account_not_logged_in" : "account_login_status_unknown", status.logged_in === false
+                ? `Account ${accountId} for ${provider} is not logged in`
+                : `Could not verify that account ${accountId} for ${provider} is logged in`, { provider, account: accountId });
+        }
+        account.enabled = true;
+        delete account.disabled_reason;
+        writeLanesConfig(hqRoot, config);
+        printJson({
+            ok: true,
+            action: "accounts.enable",
+            account: accountStatus(provider, accountId, loadLanesConfig(hqRoot), {
+                existsSync: ctx.existsSync,
+                hostname: ctx.hostname(),
+                probe: ctx.probeProvider,
+                env: ctx.env,
+            }),
+        });
+    }
+    async function runAccountsDisable(ctx, providerRaw, accountId, opts) {
+        const hqRoot = ctx.hqRoot();
+        const provider = parseLaneProvider(providerRaw);
+        const config = loadLanesConfig(hqRoot);
+        const account = config.providers[provider].accounts[accountId];
+        if (!account) {
+            throw new AccountResolutionError("unknown_account", `Unknown account ${JSON.stringify(accountId)} for ${provider}`, {
+                provider,
+                account: accountId,
+                enabled: Object.entries(config.providers[provider].accounts)
+                    .filter(([, a]) => a.enabled)
+                    .map(([id]) => id),
+            });
+        }
+        account.enabled = false;
+        if (opts.reason)
+            account.disabled_reason = opts.reason;
+        writeLanesConfig(hqRoot, config);
+        printJson({
+            ok: true,
+            action: "accounts.disable",
+            account: accountStatus(provider, accountId, loadLanesConfig(hqRoot), {
+                existsSync: ctx.existsSync,
+                hostname: ctx.hostname(),
+                probe: ctx.probeProvider,
+                env: ctx.env,
+            }),
+        });
+    }
+    return {
+        runAccountsList,
+        runAccountsBalance,
+        runAccountsLogin,
+        runAccountsSetHome,
+        runAccountsClearQuota,
+        runAccountsEnable,
+        runAccountsDisable
+    };
+}
+//# sourceMappingURL=lanes-accounts.js.map

package/dist/commands/lanes-autopilot.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+import { type ReconcileHost } from "../lib/lanes/reconcile.js";
+type WrapHandler = <Args extends unknown[]>(action: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;
+export interface LaneAutopilotReportDeps {
+    hqRoot: () => string;
+    now: () => Date;
+    currentHost: () => ReconcileHost;
+}
+export declare function registerLaneAutopilotReportCommand(parent: Command, deps: LaneAutopilotReportDeps, wrap: WrapHandler): void;
+export {};
+//# sourceMappingURL=lanes-autopilot.d.ts.map