@coswic/aipay 0.1.0

package/README.md

@@ -0,0 +1,55 @@
+# @coswic/aipay — AI-Pay CLI
+
+The command-line companion to [`@coswic/aipay-sdk`](https://www.npmjs.com/package/@coswic/aipay-sdk).
+Made for developers and for the coding agents they hand the Console prompt to.
+
+```bash
+npx @coswic/aipay init --app <client_id> --auth <authorization server> --api <api base>
+npx @coswic/aipay test
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `aipay init` | Links the project to your app: writes `.aipay/project.json` (commit it), `.env.local` (public values only, git-ignored), a start/callback route for your framework (Next.js, Express, Fastify, Hono, plain Node), `aipay-agent.md` (the developer docs, fetched once, for your agent to read offline) and installs the SDK. Never overwrites a file it did not write this run. `--dry-run` shows the plan. |
+| `aipay test` | The proof: a real sign-in through the AI-Pay authorization server, received by the CLI on a loopback callback, then one chat completion on that user's behalf. Prints the receipt (`request_id`, amount charged). The Console's verify step turns green from the server side. The authorization server ignores the port for `127.0.0.1` redirect URIs (RFC 8252), so the CLI binds any free port and your dev server can keep running; `--port <n>` forces one. `--no-open` prints the URL instead of opening a browser; `--model <id>` picks the model. |
+| `aipay doctor` | Checks Node, the link, `.env.local`, the SDK install, and that the authorization server and API are reachable. `--offline` skips the network. |
+| `aipay status` | What this directory is linked to. |
+| `aipay unlink` | Forgets the link (removes `.aipay/project.json`, strips `AIPAY_*` from `.env.local`); keeps your code. |
+
+Every command accepts `--json` (one JSON document on stdout) and `--dir <path>`.
+
+Exit codes: `0` ok · `1` a problem you can fix locally · `2` usage · `3` network/auth.
+
+## Pilot gate
+
+During the closed pilot, non-public AI-Pay paths answer `404` with an empty body unless the
+request carries the gate token. Export it and the CLI sends it as `X-AIPay-Gate`:
+
+```bash
+export AIPAY_GATE_TOKEN=<token from the Console>
+```
+
+The CLI never writes the token to any file and never prints it.
+
+## What gets written
+
+```
+.aipay/project.json   # app client_id, endpoints, callback, what was scaffolded — no secrets
+.env.local            # AIPAY_CLIENT_ID / AIPAY_AUTH_ORIGIN / AIPAY_API_BASE / AIPAY_CALLBACK_URL
+aipay-agent.md        # project facts + the developer docs, for coding agents
+src/aipay.ts          # sign-in helpers (start → callback → first completion)
+src/aipay-routes.ts   # framework wiring (or app/auth/aipay/*/route.ts for Next.js)
+```
+
+Access and refresh tokens obtained by `aipay test` live in memory only.
+
+## Development
+
+```bash
+pnpm --filter @coswic/aipay test
+pnpm --filter @coswic/aipay build
+```
+
+Zero runtime dependencies besides the SDK. Node 20+.

package/dist/agent-guide.d.ts

@@ -0,0 +1,18 @@
+/**
+ * `aipay-agent.md`: the file a coding agent reads first. Header = the facts of THIS
+ * project (app, endpoints, what was scaffolded, what "done" means); body = the AI-Pay
+ * developer docs fetched from the API (`/docs.md?lang=en`), so the agent does not need
+ * network access — or the gate token — to read them later.
+ *
+ * Never contains tokens. If the docs are gated (404 with empty body) the file still gets
+ * written with the header and a pointer, and the CLI warns.
+ */
+import type { ProjectConfig } from './project.js';
+export declare const AGENT_GUIDE_FILE = "aipay-agent.md";
+export interface GuideInput {
+    project: ProjectConfig;
+    scaffolded: string[];
+    docsMarkdown: string | null;
+    docsUrl: string;
+}
+export declare function agentGuide(input: GuideInput): string;

package/dist/agent-guide.js

@@ -0,0 +1,60 @@
+export const AGENT_GUIDE_FILE = 'aipay-agent.md';
+export function agentGuide(input) {
+    const p = input.project;
+    const files = input.scaffolded.length
+        ? input.scaffolded.map((f) => `- \`${f}\``).join('\n')
+        : '- (none — the project had them already)';
+    const head = `# AI-Pay integration guide for this project
+
+> Written by \`aipay init\` on ${p.linked_at}. Regenerate with \`aipay init --app ${p.app.client_id}\`. Safe to commit: it contains no secrets.
+
+## This project
+
+| | |
+|---|---|
+| App | ${p.app.name ?? '(unnamed)'} |
+| client_id | \`${p.app.client_id}\` (public client, PKCE S256, no secret) |
+| Authorization server | ${p.auth_origin} |
+| API base | ${p.api_base} |
+| Registered callback | \`${p.callback}\` (for 127.0.0.1 the port is not compared, so any local port works) |
+| Local config | \`.aipay/project.json\` (commit it), \`.env.local\` (do not commit) |
+
+Files scaffolded by the CLI (edit freely; the CLI never overwrites existing files):
+${files}
+
+## Definition of done
+
+1. \`aipay doctor\` reports no problems.
+2. The app's dev server serves the start route and the callback route above.
+3. \`aipay test\` completes: a real sign-in through the AI-Pay authorization server and
+   one chat completion whose response carries a receipt (\`aipay.request_id\`).
+4. Typecheck/build pass. Do not commit automatically and do not deploy.
+
+## Rules for agents
+
+- Read the docs below before changing the integration; they are the source of truth.
+- The pilot gate token comes only from the \`AIPAY_GATE_TOKEN\` environment variable.
+  Never write it into code, config files, or version control.
+- Never request \`offline_access\` unless the product needs background renewal.
+- Key user accounts on \`sub\` from the userinfo endpoint, never on email.
+
+`;
+    const body = input.docsMarkdown
+        ? `---
+
+# AI-Pay developer documentation
+
+_Fetched from ${input.docsUrl} by \`aipay init\`._
+
+${input.docsMarkdown.trim()}
+`
+        : `---
+
+# AI-Pay developer documentation
+
+The docs could not be fetched when this file was written (see the \`aipay init\` output).
+Read them at ${input.docsUrl} — during the pilot send the header \`X-AIPay-Gate\` with the
+value of \`AIPAY_GATE_TOKEN\`, or run \`aipay init\` again with the variable set.
+`;
+    return head + body;
+}

package/dist/args.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Tiny argv parser — zero deps on purpose (the CLI is installed by coding agents in
+ * arbitrary projects; every dependency is attack surface and install time).
+ *
+ * Supports `--flag`, `--flag value`, `--flag=value`, `--no-flag`, and positionals.
+ * Every flag is a string or boolean; commands coerce what they need.
+ */
+export interface ParsedArgs {
+    command: string | null;
+    positionals: string[];
+    flags: Record<string, string | boolean>;
+}
+export declare function parseArgs(argv: string[]): ParsedArgs;
+export declare function flagString(flags: ParsedArgs['flags'], name: string): string | null;
+export declare function flagBool(flags: ParsedArgs['flags'], name: string, dflt?: boolean): boolean;

package/dist/args.js

@@ -0,0 +1,47 @@
+export function parseArgs(argv) {
+    const out = { command: null, positionals: [], flags: {} };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i] ?? '';
+        if (a === '--') {
+            out.positionals.push(...argv.slice(i + 1));
+            break;
+        }
+        if (a.startsWith('--')) {
+            const body = a.slice(2);
+            const eq = body.indexOf('=');
+            if (eq >= 0) {
+                out.flags[body.slice(0, eq)] = body.slice(eq + 1);
+                continue;
+            }
+            if (body.startsWith('no-')) {
+                out.flags[body.slice(3)] = false;
+                continue;
+            }
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith('--')) {
+                out.flags[body] = next;
+                i++;
+            }
+            else
+                out.flags[body] = true;
+            continue;
+        }
+        if (out.command === null)
+            out.command = a;
+        else
+            out.positionals.push(a);
+    }
+    return out;
+}
+export function flagString(flags, name) {
+    const v = flags[name];
+    return typeof v === 'string' && v !== '' ? v : null;
+}
+export function flagBool(flags, name, dflt = false) {
+    const v = flags[name];
+    if (typeof v === 'boolean')
+        return v;
+    if (typeof v === 'string')
+        return v !== 'false' && v !== '0';
+    return dflt;
+}

package/dist/auth-store.d.ts

@@ -0,0 +1,23 @@
+export interface StoredAuth {
+    api_base: string;
+    auth_origin: string;
+    client_id: string;
+    access_token: string;
+    refresh_token: string | null;
+    /** epoch ms */
+    expires_at: number;
+    scope: string;
+    email: string | null;
+    sub: string;
+}
+export interface AuthStore {
+    kind: 'keychain' | 'file';
+    load(): StoredAuth | null;
+    save(auth: StoredAuth): void;
+    clear(): void;
+    /** Human description of where tokens are kept (for `whoami`/`login` output). */
+    where: string;
+}
+export declare function configDir(env?: NodeJS.ProcessEnv): string;
+export declare function createAuthStore(env?: NodeJS.ProcessEnv): AuthStore;
+export declare function fileStore(dir: string): AuthStore;

package/dist/auth-store.js

@@ -0,0 +1,113 @@
+/**
+ * Where the developer's management tokens live between commands.
+ *
+ * Order of preference (decision D5, 2026-09-04): the OS keychain when a CLI for it exists
+ * (macOS `security`, Linux `secret-tool`), else a 0600 file under the user's config dir
+ * with a one-line warning at login. Tokens are never written into the project directory.
+ */
+import { spawnSync } from 'node:child_process';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const SERVICE = 'aipay-cli';
+export function configDir(env = process.env) {
+    if (env.AIPAY_CONFIG_DIR)
+        return env.AIPAY_CONFIG_DIR;
+    const base = process.platform === 'win32'
+        ? (env.APPDATA ?? join(homedir(), 'AppData', 'Roaming'))
+        : (env.XDG_CONFIG_HOME ?? join(homedir(), '.config'));
+    return join(base, 'aipay');
+}
+function has(bin) {
+    const r = spawnSync(process.platform === 'win32' ? 'where' : 'which', [bin], { stdio: 'ignore' });
+    return r.status === 0;
+}
+export function createAuthStore(env = process.env) {
+    if (env.AIPAY_TOKEN_STORE !== 'file') {
+        if (process.platform === 'darwin' && has('security'))
+            return macKeychain();
+        if (process.platform === 'linux' && has('secret-tool'))
+            return secretTool();
+    }
+    return fileStore(configDir(env));
+}
+function macKeychain() {
+    const account = 'developer';
+    return {
+        kind: 'keychain',
+        where: 'macOS Keychain (service aipay-cli)',
+        load() {
+            const r = spawnSync('security', ['find-generic-password', '-a', account, '-s', SERVICE, '-w'], { encoding: 'utf8' });
+            if (r.status !== 0)
+                return null;
+            return parse(r.stdout.trim());
+        },
+        save(auth) {
+            const r = spawnSync('security', ['add-generic-password', '-U', '-a', account, '-s', SERVICE, '-w', JSON.stringify(auth)], { stdio: 'ignore' });
+            if (r.status !== 0)
+                throw new Error('could not write to the macOS Keychain');
+        },
+        clear() {
+            spawnSync('security', ['delete-generic-password', '-a', account, '-s', SERVICE], {
+                stdio: 'ignore',
+            });
+        },
+    };
+}
+function secretTool() {
+    const attrs = ['service', SERVICE, 'account', 'developer'];
+    return {
+        kind: 'keychain',
+        where: 'the system keyring (secret-tool, service aipay-cli)',
+        load() {
+            const r = spawnSync('secret-tool', ['lookup', ...attrs], { encoding: 'utf8' });
+            if (r.status !== 0 || !r.stdout)
+                return null;
+            return parse(r.stdout.trim());
+        },
+        save(auth) {
+            const r = spawnSync('secret-tool', ['store', '--label', 'AI-Pay CLI', ...attrs], {
+                input: JSON.stringify(auth),
+                stdio: ['pipe', 'ignore', 'ignore'],
+            });
+            if (r.status !== 0)
+                throw new Error('could not write to the system keyring');
+        },
+        clear() {
+            spawnSync('secret-tool', ['clear', ...attrs], { stdio: 'ignore' });
+        },
+    };
+}
+export function fileStore(dir) {
+    const file = join(dir, 'credentials.json');
+    return {
+        kind: 'file',
+        where: `${file} (mode 0600)`,
+        load() {
+            if (!existsSync(file))
+                return null;
+            return parse(readFileSync(file, 'utf8'));
+        },
+        save(auth) {
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            writeFileSync(file, `${JSON.stringify(auth, null, 2)}\n`, { mode: 0o600 });
+            chmodSync(file, 0o600);
+        },
+        clear() {
+            rmSync(file, { force: true });
+        },
+    };
+}
+function parse(raw) {
+    try {
+        const v = JSON.parse(raw);
+        if (typeof v.access_token !== 'string' ||
+            typeof v.api_base !== 'string' ||
+            typeof v.client_id !== 'string')
+            return null;
+        return v;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { main } from './main.js';
+main(process.argv.slice(2)).then((code) => {
+    process.exitCode = code;
+}, (err) => {
+    process.stderr.write(`${err instanceof Error ? (err.stack ?? err.message) : String(err)}\n`);
+    process.exitCode = 1;
+});

package/dist/browser.d.ts

@@ -0,0 +1 @@
+export declare function openBrowser(url: string, platform?: NodeJS.Platform): boolean;

package/dist/browser.js

@@ -0,0 +1,18 @@
+/** Open a URL in the user's default browser without depending on the `open` package. */
+import { spawn } from 'node:child_process';
+export function openBrowser(url, platform = process.platform) {
+    const [cmd, args] = platform === 'darwin'
+        ? ['open', [url]]
+        : platform === 'win32'
+            ? ['cmd', ['/c', 'start', '', url.replace(/&/g, '^&')]]
+            : ['xdg-open', [url]];
+    try {
+        const child = spawn(cmd, args, { stdio: 'ignore', detached: true });
+        child.on('error', () => { });
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/apps.d.ts

@@ -0,0 +1,15 @@
+import { type ParsedArgs } from '../args.js';
+import { type DeveloperApi } from '../developer-api.js';
+import { type Reporter } from '../output.js';
+export interface CreatedApp {
+    app_id: string;
+    client_id: string;
+    redirect_uris: string[];
+    replayed?: boolean;
+}
+export declare function createApp(api: DeveloperApi, input: {
+    name: string;
+    callback: string;
+    key?: string | null;
+}): Promise<CreatedApp>;
+export declare function runApps(args: ParsedArgs, out: Reporter, env?: NodeJS.ProcessEnv): Promise<number>;

package/dist/commands/apps.js

@@ -0,0 +1,53 @@
+/**
+ * `aipay apps list [--json]`
+ * `aipay apps create --name <name> [--callback <uri>] [--key <idempotency key>] [--json]`
+ *
+ * Uses the developer's management token. Creation sends an Idempotency-Key so a retried
+ * command never makes a second app.
+ */
+import { randomUUID } from 'node:crypto';
+import { flagString } from '../args.js';
+import { createAuthStore } from '../auth-store.js';
+import { errorMessage, openDeveloperApi } from '../developer-api.js';
+import { CliError, EXIT } from '../output.js';
+import { DEFAULT_CALLBACK } from './init.js';
+export async function createApp(api, input) {
+    const key = input.key ?? `aipay-cli-${randomUUID()}`;
+    const res = await api.request('POST', '/v1/developer/apps', {
+        body: { name: input.name, redirect_uris: [input.callback] },
+        headers: { 'idempotency-key': key },
+    });
+    if (res.status !== 201 && res.status !== 200)
+        throw new CliError('create_failed', `could not create the app: ${errorMessage(res.body, res.status)}`, EXIT.remote);
+    return res.body;
+}
+export async function runApps(args, out, env = process.env) {
+    const sub = args.positionals[0] ?? 'list';
+    const store = createAuthStore(env);
+    const api = await openDeveloperApi(store, env);
+    if (sub === 'list') {
+        const res = await api.request('GET', '/v1/developer/apps');
+        if (res.status !== 200)
+            throw new CliError('remote', `GET /v1/developer/apps → ${errorMessage(res.body, res.status)}`, EXIT.remote);
+        const apps = Array.isArray(res.body) ? res.body : (res.body.data ?? res.body.apps ?? []);
+        if (!apps.length)
+            out.line('info', 'no apps yet — `aipay apps create --name "My app"`');
+        for (const a of apps)
+            out.line('info', `${String(a.name ?? '?')}  ${String(a.id ?? a.app_id ?? a.client_id ?? '')}  ${String(a.status ?? '')}`);
+        out.result({ ok: true, apps });
+        return EXIT.ok;
+    }
+    if (sub === 'create') {
+        const name = flagString(args.flags, 'name');
+        if (!name)
+            throw new CliError('usage', 'missing --name <app name>', EXIT.usage);
+        const callback = flagString(args.flags, 'callback') ?? DEFAULT_CALLBACK;
+        const created = await createApp(api, { name, callback, key: flagString(args.flags, 'key') });
+        out.line('ok', `${created.replayed ? 'already created' : 'created'} "${name}" — client_id ${created.client_id}`);
+        out.kv('callback', created.redirect_uris.join(', '));
+        out.line('info', `next: aipay init --app ${created.client_id}`);
+        out.result({ ok: true, ...created, name });
+        return EXIT.ok;
+    }
+    throw new CliError('usage', `unknown apps subcommand "${sub}" (list | create)`, EXIT.usage);
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,17 @@
+import { type ParsedArgs } from '../args.js';
+import { type Level, type Reporter } from '../output.js';
+import { type Remote } from '../remote.js';
+export interface Check {
+    id: string;
+    level: Level;
+    text: string;
+}
+export interface DoctorDeps {
+    remote?: Remote;
+    env?: NodeJS.ProcessEnv;
+    nodeVersion?: string;
+}
+export declare function runDoctor(args: ParsedArgs, out: Reporter, deps?: DoctorDeps): Promise<number>;
+export declare function collectChecks(dir: string, opts: {
+    offline: boolean;
+}, deps: DoctorDeps, env: NodeJS.ProcessEnv): Promise<Check[]>;

package/dist/commands/doctor.js

@@ -0,0 +1,153 @@
+/**
+ * `aipay doctor [--dir] [--json] [--offline]` — checks the link, the local files, the
+ * SDK install, and (unless --offline) reachability of the authorization server and the
+ * API. Exit 0 = nothing to fix, 1 = at least one problem.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { flagBool, flagString } from '../args.js';
+import { detectProject } from '../detect.js';
+import { GATE_ENV } from '../gate.js';
+import { parseCallback } from '../loopback.js';
+import { EXIT } from '../output.js';
+import { ENV_FILE, ENV_KEYS, readProject } from '../project.js';
+import { createRemote, docsUrl, GATE_HINT } from '../remote.js';
+export async function runDoctor(args, out, deps = {}) {
+    const dir = resolve(flagString(args.flags, 'dir') ?? '.');
+    const env = deps.env ?? process.env;
+    const checks = await collectChecks(dir, { offline: flagBool(args.flags, 'offline') }, deps, env);
+    for (const c of checks)
+        out.line(c.level, c.text);
+    const problems = checks.filter((c) => c.level === 'bad');
+    out.blank();
+    out.line(problems.length ? 'bad' : 'ok', problems.length ? `${problems.length} problem(s)` : 'all good');
+    out.result({ ok: problems.length === 0, dir, checks });
+    return problems.length ? EXIT.problem : EXIT.ok;
+}
+export async function collectChecks(dir, opts, deps, env) {
+    const checks = [];
+    const major = Number((deps.nodeVersion ?? process.versions.node).split('.')[0]);
+    checks.push(major >= 20
+        ? { id: 'node', level: 'ok', text: `Node ${deps.nodeVersion ?? process.versions.node}` }
+        : {
+            id: 'node',
+            level: 'bad',
+            text: `Node ${deps.nodeVersion ?? process.versions.node} — the SDK needs 20+`,
+        });
+    let project = null;
+    try {
+        project = readProject(dir);
+    }
+    catch (e) {
+        checks.push({ id: 'project', level: 'bad', text: e.message });
+        return checks;
+    }
+    if (!project) {
+        checks.push({
+            id: 'project',
+            level: 'bad',
+            text: 'not linked — run `aipay init --app <client_id> --auth <origin> --api <base>`',
+        });
+        return checks;
+    }
+    checks.push({
+        id: 'project',
+        level: 'ok',
+        text: `linked to ${project.app.name ?? project.app.client_id} (.aipay/project.json)`,
+    });
+    try {
+        const t = parseCallback(project.callback);
+        checks.push({
+            id: 'callback',
+            level: 'ok',
+            text: `callback ${project.callback} (loopback, port ${t.port})`,
+        });
+    }
+    catch (e) {
+        checks.push({ id: 'callback', level: 'bad', text: `callback: ${e.message}` });
+    }
+    const envPath = join(dir, ENV_FILE);
+    if (!existsSync(envPath))
+        checks.push({ id: 'env', level: 'bad', text: `${ENV_FILE} missing — rerun \`aipay init\`` });
+    else {
+        const content = readFileSync(envPath, 'utf8');
+        const want = {
+            [ENV_KEYS.clientId]: project.app.client_id,
+            [ENV_KEYS.authOrigin]: project.auth_origin,
+            [ENV_KEYS.apiBase]: project.api_base,
+            [ENV_KEYS.callback]: project.callback,
+        };
+        const wrong = Object.entries(want)
+            .filter(([k, v]) => !new RegExp(`^\\s*(?:export\\s+)?${k}\\s*=\\s*["']?${escapeRe(v)}["']?\\s*$`, 'm').test(content))
+            .map(([k]) => k);
+        checks.push(wrong.length
+            ? {
+                id: 'env',
+                level: 'bad',
+                text: `${ENV_FILE} out of sync: ${wrong.join(', ')} — rerun \`aipay init\``,
+            }
+            : { id: 'env', level: 'ok', text: `${ENV_FILE} has the four AIPAY_* values` });
+    }
+    const gi = join(dir, '.gitignore');
+    if (existsSync(gi) &&
+        !readFileSync(gi, 'utf8')
+            .split(/\r?\n/)
+            .some((l) => l.trim() === ENV_FILE))
+        checks.push({ id: 'gitignore', level: 'warn', text: `.gitignore does not list ${ENV_FILE}` });
+    const det = detectProject(dir);
+    if (det.hasPackageJson) {
+        const installed = det.sdkInstalled && existsSync(join(dir, 'node_modules', '@coswic', 'aipay-sdk'));
+        checks.push(installed
+            ? { id: 'sdk', level: 'ok', text: '@coswic/aipay-sdk installed' }
+            : det.sdkInstalled
+                ? {
+                    id: 'sdk',
+                    level: 'bad',
+                    text: '@coswic/aipay-sdk is in package.json but not installed — run your package manager install',
+                }
+                : {
+                    id: 'sdk',
+                    level: 'bad',
+                    text: '@coswic/aipay-sdk not a dependency — rerun `aipay init` (or add it yourself)',
+                });
+        for (const f of project.scaffold.files)
+            if (!existsSync(join(dir, f)))
+                checks.push({ id: 'scaffold', level: 'warn', text: `scaffolded file removed: ${f}` });
+    }
+    if (!env[GATE_ENV])
+        checks.push({
+            id: 'gate',
+            level: 'info',
+            text: `${GATE_ENV} not set (fine after the pilot; required during it)`,
+        });
+    if (!opts.offline) {
+        const remote = deps.remote ?? createRemote(env);
+        const oidc = await remote.probe(new URL('/.well-known/openid-configuration', project.auth_origin).toString());
+        checks.push(oidc.ok
+            ? {
+                id: 'auth',
+                level: 'ok',
+                text: `authorization server reachable (${project.auth_origin})`,
+            }
+            : {
+                id: 'auth',
+                level: 'bad',
+                text: `authorization server ${project.auth_origin}: ${oidc.error ?? `HTTP ${oidc.status}`}`,
+            });
+        const api = await remote.probe(docsUrl(project.api_base, 'en'));
+        if (api.ok)
+            checks.push({ id: 'api', level: 'ok', text: `API reachable (${project.api_base})` });
+        else if (api.gated)
+            checks.push({ id: 'api', level: 'bad', text: `API ${project.api_base}: ${GATE_HINT}` });
+        else
+            checks.push({
+                id: 'api',
+                level: 'bad',
+                text: `API ${project.api_base}: ${api.error ?? `HTTP ${api.status}`}`,
+            });
+    }
+    return checks;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,18 @@
+import { type ParsedArgs } from '../args.js';
+import { type StoredAuth } from '../auth-store.js';
+import { type DeveloperApi } from '../developer-api.js';
+import { type Reporter } from '../output.js';
+import { type Remote } from '../remote.js';
+export declare const DEFAULT_CALLBACK = "http://127.0.0.1:3000/auth/aipay/callback";
+export declare const SDK_PACKAGE = "@coswic/aipay-sdk";
+export interface InitDeps {
+    remote?: Remote;
+    /** Injected for tests: the developer login (null = signed out). */
+    login?: StoredAuth | null;
+    developerApi?: DeveloperApi;
+    now?: () => Date;
+    /** Runs the package-manager install; returns exit code. Injected for tests. */
+    run?: (cmd: string[], cwd: string, quiet: boolean) => number;
+    env?: NodeJS.ProcessEnv;
+}
+export declare function runInit(args: ParsedArgs, out: Reporter, deps?: InitDeps): Promise<number>;