looply-cli 0.0.0-stage → 0.2.0

package/dist/provider-preflight.js

@@ -0,0 +1,395 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PREFLIGHT_TIMEOUT_MS = exports.PREFLIGHT_PROMPT = exports.PREFLIGHT_TOKEN = void 0;
+exports.preflightCommandLine = preflightCommandLine;
+exports.preflightProvider = preflightProvider;
+exports.preflightPasses = preflightPasses;
+exports.preflightEnv = preflightEnv;
+exports.nodePreflightDeps = nodePreflightDeps;
+const exec_domains_1 = require("./exec-domains");
+const model_transport_1 = require("./model-transport");
+const agent_exec_1 = require("./agent-exec");
+const command_runner_1 = require("./command-runner");
+/**
+ * DOES THE CONFIGURED PROVIDER ACTUALLY ANSWER?
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THIS IS THE ONLY THING THAT MAKES A PRESET TRUSTWORTHY.
+ *
+ * `providers.ts` ships command lines, and two of the three have never been run
+ * by anybody here — the binaries are not installed on the machine they were
+ * written on. No amount of care in a table fixes that. What fixes it is running
+ * the thing on the machine that HAS it and reporting what happened, which is
+ * what this does.
+ *
+ * ⚠️ `looply doctor` DELIBERATELY MAKES NO AGENT CALL — it exists to find a
+ * wrong `tsc` command in ninety seconds. That was the right decision for the
+ * gate and it left a hole either side of it: a wrong AGENT command was found at
+ * round 1 of an overnight run, by which point a person is asleep. This is the
+ * other half, and it is opt-in for the same reason doctor is fast: it spends a
+ * model call.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 WHAT IT ASKS FOR, AND WHY THAT EXACT SHAPE
+ *
+ * A prompt with one instruction and a literal answer. Not "hello", which any
+ * process echoing its input would pass; not a code task, which spends real
+ * money and takes real time. A token the provider could only produce by having
+ * read the prompt and generated from it.
+ *
+ * ⚠️ IT STILL CANNOT PROVE THE MODEL IS ANY GOOD. It proves the process starts,
+ * accepts a prompt on stdin, and returns something derived from it. That is
+ * exactly the class of failure the flags cause, and no more.
+ */
+/** The word the probe asks for, chosen to be one nothing else would emit. */
+exports.PREFLIGHT_TOKEN = 'looply-preflight-ok';
+exports.PREFLIGHT_PROMPT = `Reply with exactly this word and nothing else: ${exports.PREFLIGHT_TOKEN}`;
+/**
+ * How long to wait before calling it hung.
+ *
+ * 🔴 A HANG IS THE FAILURE THIS EXISTS TO CATCH, so the timeout is not a
+ * formality. An AppContainer that cannot create a named pipe returns EACCES and
+ * the spawn waits FOR EVER rather than failing — that is measured behaviour in
+ * this repository, and without a ceiling this check would inherit it.
+ */
+exports.PREFLIGHT_TIMEOUT_MS = 120_000;
+/**
+ * The command line the preflight actually spawns.
+ *
+ * 🔴 THE BUILT-IN PROVIDER HAS TO BE SPAWNED BY ABSOLUTE PATH, BECAUSE THIS
+ * CHECK'S OWN ENVIRONMENT CANNOT FIND IT BY NAME. `buildProviderEnv` pins PATH
+ * to the system directories deliberately — "not the machine's toolchain
+ * directory, which on this machine also holds `claude`" — so the bare `claude`
+ * in `DEFAULT_AGENT.command` resolves to nothing and `cmd` answers "is not
+ * recognized as an internal or external command".
+ *
+ * MEASURED: `looply doctor --provider` returned `missing` in 18 ms on a machine
+ * where the provider was installed, logged in, and perfectly able to run —
+ * three lines after `checkProviderAuth` had resolved its absolute path and
+ * printed "logged in (claude.ai)". The check contradicted itself inside one
+ * command, and it contradicted the run: `model-transport` spawns
+ * `spec.executable ?? providerExecutableFor(pkg)` and never consults PATH.
+ *
+ * A check that REFUSES a configuration the run ACCEPTS is the mirror of the
+ * defect this file's own header warns about, and costs the same thing — a
+ * person is told the provider is missing and goes looking for an install that
+ * is already there.
+ *
+ * ⚠️ ONLY THE BUILT-IN IS REWRITTEN. A configured `agent.command` is the
+ * person's own line, and rewriting it would discard exactly the intent
+ * `resolveProvider` takes such care to keep. An explicit `agent.executable` is
+ * already absolute and the transport already prefers it.
+ */
+function preflightCommandLine(spec, executable) {
+    if (executable === null || spec.executable !== undefined || spec.command !== agent_exec_1.DEFAULT_AGENT.command) {
+        return (0, agent_exec_1.agentCommandLine)(spec, 'text');
+    }
+    const args = agent_exec_1.DEFAULT_AGENT.command.split(' ').slice(1);
+    // Quoted because the ordinary install path — `C:\Program Files\nodejs\…` —
+    // contains a space, and an unquoted one is two arguments to `cmd`.
+    return (0, agent_exec_1.agentCommandLine)({ ...spec, command: [`"${executable}"`, ...args].join(' ') }, 'text');
+}
+/** Enough to identify the failure, never enough to be a transcript. */
+const MAX_DETAIL = 400;
+function clip(s) {
+    const t = s.trim().replace(/\s+/g, ' ');
+    return t.length <= MAX_DETAIL ? t : `${t.slice(0, MAX_DETAIL)}…`;
+}
+/**
+ * ⚠️ `missing` IS DETECTED FROM THE MESSAGE AS WELL AS THE EXIT CODE, and the
+ * message is still the weaker half. A provider refusing a FLAG also exits 1 on
+ * Windows `cmd`, so the code alone cannot separate "no such program" from "bad
+ * option" there — the wording is what separates them.
+ *
+ * 🔴 AND IT KNEW ONE POSIX SHELL'S WORDING, NOT THE ONE MOST HOSTS USE. bash
+ * says "command not found"; `/bin/sh` is dash on Debian and Ubuntu, and dash
+ * says `sh: 1: name: not found`. A missing binary was therefore classified
+ * `refused` on the commonest POSIX host — and the two have different fixes, one
+ * a name or a PATH and the other a flag, which is the whole reason this
+ * distinction exists. The advice it printed sent a person to look at their flags
+ * for a binary that was not installed.
+ */
+function looksMissing(text) {
+    return /not recognized as an internal or external command|command not found|: not found|ENOENT|No such file or directory|is not recognized/i.test(text);
+}
+/**
+ * Exit statuses that mean "no such program", whatever was printed.
+ *
+ * 127 is the POSIX shell's own convention for a command it could not find, and
+ * 9009 is `cmd.exe`'s. Both are narrow enough not to collide with a provider's
+ * own failure codes — a program that did start and then failed does not pick
+ * these — so they are a second, wording-independent way to tell the two problems
+ * apart.
+ */
+const MISSING_EXIT_CODES = [127, 9009];
+async function preflightProvider(spec, deps) {
+    // The spec is NOT rewritten — the `no_host_tools` rule below asks about
+    // `spec.command`, and a resolved absolute path would read as a configured
+    // provider and demand a declaration the built-in does not need.
+    const commandLine = preflightCommandLine(spec, deps.executable ?? null);
+    const started = deps.now();
+    /**
+     * 🔴 A CHECK THAT PASSES A CONFIGURATION THE RUN REFUSES IS WORSE THAN NO
+     * CHECK, AND THAT IS EXACTLY WHAT THIS DID.
+     *
+     * MEASURED: `looply doctor --provider` — the documented way to confirm a
+     * provider — returned PASS, exit 0, on the very configuration where every
+     * `looply run` model call is refused for a missing `agent.no_host_tools`.
+     * A person ran the check looply told them to run, was told everything was
+     * fine, and then lost the first round of an overnight run to a refusal this
+     * command could have named in a millisecond.
+     *
+     * ⚠️ AND IT IS CHECKED BEFORE THE SPAWN, not after. There is nothing to
+     * learn from starting a provider that will not be started this way, and
+     * spawning one costs a model session.
+     *
+     * This mirrors `model-transport`'s rule rather than restating it: a
+     * configured provider — one whose command is not the built-in — must say how
+     * its own tools are turned off.
+     */
+    if (spec.command !== agent_exec_1.DEFAULT_AGENT.command && (spec.noHostTools ?? []).length === 0) {
+        return {
+            verdict: 'refused',
+            ms: deps.now() - started,
+            detail: 'this project configures its own agent command but does not set `agent.no_host_tools`, ' +
+                'so every model call in a run is refused before the provider is started.',
+            advice: 'Set `agent.no_host_tools` to the arguments that turn this binary\'s own tools off. Looply ' +
+                'gives a model no host tools and cannot guess that argument for a binary it does not know — ' +
+                'a guessed flag that silently does nothing reads exactly like one that works.',
+        };
+    }
+    let out;
+    try {
+        out = await deps.run({
+            commandLine,
+            prompt: exports.PREFLIGHT_PROMPT,
+            timeoutMs: exports.PREFLIGHT_TIMEOUT_MS,
+        });
+    }
+    catch (e) {
+        const message = clip(e?.message ?? String(e));
+        const missing = looksMissing(message);
+        return {
+            verdict: missing ? 'missing' : 'refused',
+            ms: deps.now() - started,
+            detail: message,
+            advice: missing
+                ? `Looply could not start "${commandLine.split(' ')[0]}". Check the binary is installed and on PATH, then set agent.command if it is named differently here.`
+                : 'The provider could not be started. The message above is what the operating system said.',
+        };
+    }
+    const ms = deps.now() - started;
+    const combined = `${out.stdout}\n${out.stderr}`;
+    if (out.timedOut) {
+        return {
+            verdict: 'hung',
+            ms,
+            detail: clip(combined) || 'no output before the ceiling',
+            advice: 'The provider produced nothing and did not exit. This is what a wrong flag looks like when the binary waits for input it will never get, and it is the failure mode that costs a whole overnight run.',
+        };
+    }
+    if (looksMissing(combined) || (out.code !== null && MISSING_EXIT_CODES.includes(out.code))) {
+        return {
+            verdict: 'missing',
+            ms,
+            detail: clip(combined),
+            advice: `Looply could not start "${commandLine.split(' ')[0]}". Check the binary is installed and on PATH.`,
+        };
+    }
+    if (out.code !== 0 && out.code !== null) {
+        return {
+            verdict: 'refused',
+            ms,
+            detail: clip(combined),
+            advice: 'The provider started and exited with an error, which usually means a flag it does not recognise. Compare agent.command against its own --help.',
+        };
+    }
+    // 🔴 THE TOKEN IS LOOKED FOR IN THE WHOLE OUTPUT, NOT AT THE END. Providers
+    // print banners, spinners and usage lines around an answer, and requiring it
+    // to be the entire response would fail every provider that is polite.
+    if (combined.includes(exports.PREFLIGHT_TOKEN)) {
+        return { verdict: 'answered', ms, detail: '', advice: '' };
+    }
+    return {
+        verdict: 'unrecognised',
+        ms,
+        detail: clip(combined),
+        advice: 'The provider ran and answered, but not with what was asked for. It may still work — or it may not be reading the prompt from stdin at all, which would look exactly like this. Compare the output above against what you expected.',
+    };
+}
+/** Whether a run should be allowed to start on this result. */
+function preflightPasses(r) {
+    // ⚠️ `unrecognised` PASSES, DELIBERATELY. It means "answered, but not the way
+    // this probe hoped", and a provider that prefixes its output or declines the
+    // instruction is not a broken one. Blocking on it would make the check a
+    // gatekeeper for a prompt-following ability nobody promised.
+    return r.verdict === 'answered' || r.verdict === 'unrecognised';
+}
+/* ─────────────────────────────────────────────────────── real processes ── */
+/**
+ * The real implementation, kept out of the module above so its logic stays
+ * drivable without spawning anything.
+ *
+ * 🔴 THE ENVIRONMENT HAD TO MATCH THE TRANSPORT'S, AND THE OLD DOCBLOCK
+ * CLAIMED IT ALREADY DID.
+ *
+ * It said "`shell: true` MATCHES HOW THE TRANSPORT STARTS THE PROVIDER", while
+ * the transport's own docblock says "NEVER `shell: true`" — and, far worse,
+ * this spawn passed no `env` at all, so the child inherited the OPERATOR'S
+ * ENTIRE AMBIENT ENVIRONMENT and their real HOME.
+ *
+ * MEASURED: the preflight child saw an injected marker variable and the
+ * operator's own home directory; the transport gives a scrubbed environment and
+ * a HOME redirected into `.looply/provider-sessions`. So a provider that
+ * authenticates from the operator's real home, or that is found on the
+ * operator's PATH rather than in `agent.runtime`, PASSED this check and then
+ * could not start in the run — precisely the failure the preflight exists to
+ * prevent, with the check itself supplying the credentials.
+ *
+ * ⚠️ THE SHELL STAYS, because the thing being checked IS a command line and
+ * the transport also reaches a configured provider through `cmd /c`. What
+ * changes is the environment that shell is given: `buildProviderEnv` over a
+ * session directory — the same function, and the same shape, the transport uses.
+ */
+/**
+ * The environment a preflight hands the provider, as a pure function of its three
+ * inputs — so a test can hold it against what the transport builds.
+ *
+ * 🔴 EXTRACTED BECAUSE THE DIVERGENCE WAS INVISIBLE. It lived inside the spawn
+ * closure, where nothing could observe it, and it quietly omitted
+ * `CLAUDE_CONFIG_DIR` while `model-transport` always set it. The result was a
+ * readiness check that reported `refused` for a provider the run would have
+ * authenticated, advising the operator to go and compare command-line flags.
+ */
+function preflightEnv(base, runtime, profile) {
+    const withPath = runtime.length === 0
+        ? base
+        : { ...base, PATH: [...runtime, base['PATH'] ?? ''].filter((x) => x.length > 0).join(';') };
+    // The same provider-behaviour pin the transport sets, or the readiness check
+    // would ask a provider that cannot see its tools whether it is ready to work.
+    return profile === undefined ? withPath : { ...withPath, CLAUDE_CONFIG_DIR: profile, ...model_transport_1.BUILT_IN_PROVIDER_ENV };
+}
+/**
+ * @param runtime `agent.runtime`, prepended to PATH exactly as the transport does.
+ * @param profile The provider profile directory, set as `CLAUDE_CONFIG_DIR`.
+ *
+ * 🔴 THE PROFILE IS NOT OPTIONAL DECORATION. `buildProviderEnv` hands the provider
+ * an isolated HOME, so without `CLAUDE_CONFIG_DIR` the binary looks for its login
+ * in a directory nothing has ever logged into — and answers "Not logged in" for a
+ * profile the RUN never uses. Measured on a machine whose operator was logged in
+ * perfectly well: `doctor --provider` said `refused`, and advised checking flags.
+ *
+ * ⚠️ NO CREDENTIAL PASSES THROUGH HERE. This is a directory NAME. The provider owns
+ * its own login inside it; Looply names the place and holds nothing.
+ */
+function nodePreflightDeps(runtime = [], profile, executable) {
+    return {
+        now: () => Date.now(),
+        ...(executable === undefined ? {} : { executable }),
+        run: ({ commandLine, prompt, timeoutMs }) => new Promise((resolve, reject) => {
+            // Required lazily so importing this module costs nothing in tests that
+            // only exercise the classifier.
+            const { spawn } = require('node:child_process');
+            const sessionDir = (0, model_transport_1.providerSessionDir)(process.cwd(), 'implementer');
+            const base = (0, exec_domains_1.buildProviderEnv)(sessionDir);
+            /**
+             * ⚠️ AND THE SAME RUNTIME PATHS, or this check becomes STRICTER than the
+             * run — the opposite error, and just as bad. The transport prepends
+             * `agent.runtime` to PATH for a configured provider; a preflight that
+             * did not would refuse a binary the run finds perfectly well.
+             */
+            const env = preflightEnv(base, runtime, profile);
+            const child = spawn(commandLine, {
+                shell: true,
+                cwd: sessionDir,
+                env: env,
+                /**
+                 * 🔴 ITS OWN PROCESS GROUP, OR THE KILL BELOW CANNOT REACH THE
+                 * PROVIDER AT ALL.
+                 *
+                 * `shell: true` makes `child` the SHELL and the provider its
+                 * grandchild — which the timer below already knows, and answers with
+                 * `nodeKillTree`. But on POSIX that killer is `kill(-pid)`, a
+                 * PROCESS GROUP signal, and a child spawned without this shares the
+                 * group of whoever started looply. The group kill then fails, the
+                 * fallback reaps the shell, and the provider survives the ceiling —
+                 * the precise outcome the comment below says must not happen, still
+                 * happening off Windows. `nodeSpawn` in `command-runner.ts` has set
+                 * this for the same reason all along; this spawn was the one that did
+                 * not.
+                 *
+                 * ⚠️ NOT ON WINDOWS, where it would open a new console instead and
+                 * `taskkill /T` walks the tree by itself. Not `unref`'d either: the
+                 * preflight is still waiting for this child.
+                 */
+                detached: process.platform !== 'win32',
+            });
+            let stdout = '';
+            let stderr = '';
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                // 🔴 THE TREE, NOT THE CHILD. `shell: true` on Windows runs
+                // `cmd.exe /d /s /c "<command>"`, so `child` is the SHELL and the
+                // provider is its grandchild. `child.kill()` reaps the shell and
+                // leaves the provider running — measured, not assumed: a test that
+                // waits for a survivor to write a marker file caught exactly this.
+                //
+                // A provider left alive after the ceiling is a process nobody is
+                // waiting for and nobody will reap, each holding a model session
+                // open. `nodeKillTree` is the repository's existing answer, used by
+                // the agent transport for the same reason.
+                void (0, command_runner_1.nodeKillTree)(child.pid ?? 0);
+                resolve({ stdout, stderr, code: null, timedOut: true });
+            }, timeoutMs);
+            child.stdout?.on('data', (d) => (stdout += d.toString('utf8')));
+            child.stderr?.on('data', (d) => (stderr += d.toString('utf8')));
+            child.on('error', (e) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                reject(e);
+            });
+            child.on('close', (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                resolve({ stdout, stderr, code, timedOut: false });
+            });
+            /**
+             * 🔴 A CHILD THAT NEVER READ THE PROMPT MUST NOT CRASH THE CHECK.
+             *
+             * A missing binary makes the shell exit immediately, so the pipe is gone
+             * before this write lands and Node raises `EPIPE` as an ERROR EVENT on
+             * `stdin` — not as a throw, so the try/catch below never saw it, and an
+             * unhandled stream error is an uncaught exception. The symptom was a
+             * `write EPIPE` escaping `looply doctor --provider` instead of the
+             * "missing — check the binary is installed and on PATH" it exists to
+             * print, on exactly the configuration it was run to diagnose. It is a
+             * race with the child's exit, which is why it showed up under load and
+             * not on a quiet machine.
+             *
+             * ⚠️ IGNORED, NOT REPORTED. The child's own `close` carries the exit
+             * status the classifier reads, and that is the better evidence: a pipe
+             * error means the provider was not listening, which is a fact about the
+             * provider and not about this write. A write that fails for any other
+             * reason leaves the child waiting on input it will never get, and the
+             * ceiling above reports that honestly as `hung`.
+             */
+            child.stdin?.on('error', () => {
+                /* the child is gone or not reading; its exit is the answer */
+            });
+            try {
+                child.stdin?.end(prompt);
+            }
+            catch {
+                // Reported through the error listener above.
+            }
+        }),
+    };
+}
+//# sourceMappingURL=provider-preflight.js.map

package/dist/provider-preflight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-preflight.js","sourceRoot":"","sources":["../src/provider-preflight.ts"],"names":[],"mappings":"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"}

package/dist/provider-state.d.ts

@@ -0,0 +1,120 @@
+/**
+ * WHO OWNS THE PROVIDER'S CREDENTIAL. NOT LOOPLY.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * 🔴 THIS FILE USED TO COPY THE OPERATOR'S SUBSCRIPTION CREDENTIAL INTO EVERY
+ * RUN. `seedProviderState` read `~/.claude/.credentials.json` and wrote it into
+ * each run's sterile session directory, once per launch. It worked, and it was
+ * never approved as a design: Looply held a copy of a credential it does not
+ * own, in a directory it also sweeps as residue, once per execution. Nine such
+ * copies were found on this machine and disposed of.
+ *
+ * The provider owns its own credential now. Looply stores a PATH.
+ *
+ * ─────────────────────────────────────────────────────────────────────────────
+ * HOW IT WORKS, AND WHY THIS PARTICULAR MECHANISM.
+ *
+ * `CLAUDE_CONFIG_DIR` relocates the provider's whole profile — where it looks
+ * for credentials and where it keeps project state. Verified against the
+ * installed 2.1.260 rather than assumed: pointed at an empty directory, `auth
+ * status` reported `loggedIn: false` and a `projectsDirectory` inside it. Both
+ * halves matter. It relocates, AND it starts clean rather than inheriting the
+ * operator's `~/.claude` login, settings, hooks, plugins or transcripts.
+ *
+ * ⚠️ THE PROFILE IS MACHINE STATE, NOT PROJECT STATE. It is resolved from the
+ * daemon's own home, never from `.looply/config.yaml` — that file is inside the
+ * worktree, which the model may edit. A worker that could name the provider
+ * profile could point it at a directory it had written.
+ *
+ * ⚠️ AND IT IS DELIBERATELY NOT UNDER `provider-sessions/`. That tree is
+ * residue: `workspace-residue-sweep` deletes it when a workspace is retired. A
+ * credential store inside a cleanup root is a credential store a reap destroys.
+ *
+ * ⚠️ WHAT THIS DOES NOT CLAIM. Not process confinement — the provider still runs
+ * with host-user authority and can read what the operator can read. Not separate
+ * account quotas, not logout independence on the account side, and not secure
+ * erasure of anything. It is narrower than all of those: Looply no longer copies
+ * or handles the credential, and the provider manages its own.
+ */
+/**
+ * The persistent, operator-controlled provider profile.
+ *
+ * One per machine, beside Looply's other machine state. The operator logs into
+ * it once with the provider's own flow; nothing here reads what lands there.
+ */
+/**
+ * The provider executable inside an installed Claude Code package.
+ *
+ * 🔴 ONE DEFINITION, BECAUSE TWO WOULD DRIFT. `model-transport` composes this
+ * path to launch the provider and `doctor` needs the identical one to ask whether
+ * that provider is logged in. A readiness check against a different binary is the
+ * same class of mistake as one against a different profile: it answers honestly
+ * about something nobody is going to run.
+ *
+ * `null` in, `null` out — no package, no executable, and the caller says so in
+ * its own words.
+ */
+export declare function providerExecutableFor(packageDir: string | null): string | null;
+export declare function providerProfileDir(deps?: ProviderStateDeps): string;
+export interface ProviderStateDeps {
+    /** The daemon's own home. Overridable so tests never touch the real one. */
+    home?: string;
+    /** Overridable so a test can drive a fake `auth status`. */
+    run?: (exe: string, argv: readonly string[], env: Record<string, string>, timeoutMs: number) => string;
+    timeoutMs?: number;
+}
+/**
+ * Why a launch cannot proceed, kept apart on purpose.
+ *
+ * 🔴 "PLEASE LOG IN" IS THE WRONG ANSWER TO FOUR OF THESE FIVE. A missing
+ * executable, an unparseable answer, a crashed subprocess and a timeout are all
+ * different problems with different fixes, and collapsing them into a login
+ * prompt sends somebody to re-authenticate an account that was never the
+ * trouble. Only `unauthenticated` means log in.
+ */
+export type ProviderAuthState = {
+    ok: true;
+    profile: string;
+    method: string;
+} | {
+    ok: false;
+    reason: 'unauthenticated';
+    profile: string;
+    because: string;
+} | {
+    ok: false;
+    reason: 'no_executable';
+    profile: string;
+    because: string;
+} | {
+    ok: false;
+    reason: 'unreadable_status';
+    profile: string;
+    because: string;
+} | {
+    ok: false;
+    reason: 'status_failed';
+    profile: string;
+    because: string;
+} | {
+    ok: false;
+    reason: 'timed_out';
+    profile: string;
+    because: string;
+};
+/**
+ * Is the provider ready to authenticate itself, in the profile the run will use?
+ *
+ * ⚠️ NO MODEL IS INVOKED. `auth status` is a local command that prints the
+ * profile's own state as JSON. Checking whether a login exists must not cost a
+ * turn, and a check that did would be a check nobody could afford to run.
+ *
+ * ⚠️ AND IT ASKS IN THE SAME PROFILE THE RUN WILL USE. A readiness check against
+ * a different `CLAUDE_CONFIG_DIR` answers a different question, which is exactly
+ * the class of mistake `doctor --provider` was repaired for once already.
+ *
+ * Nothing here reads, parses, copies or transports a credential. The only thing
+ * consumed is a boolean and a method name.
+ */
+export declare function checkProviderAuth(executable: string, env: Record<string, string>, deps?: ProviderStateDeps): ProviderAuthState;
+//# sourceMappingURL=provider-state.d.ts.map

package/dist/provider-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-state.d.ts","sourceRoot":"","sources":["../src/provider-state.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AAEH;;;;;GAKG;AACH;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAE9E;AAED,wBAAgB,kBAAkB,CAAC,IAAI,GAAE,iBAAsB,GAAG,MAAM,CAEvE;AAED,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;IACvG,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC7C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC1E;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACxE;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC5E;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACxE;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAkBzE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,MAAM,EAClB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC3B,IAAI,GAAE,iBAAsB,GAC3B,iBAAiB,CAqFnB"}