@agentage/cli 0.38.1 → 0.40.0

package/dist/core/profile/register.js

@@ -0,0 +1,57 @@
+import { VERSION } from '../../utils/version.js';
+import { errorCode } from './cloud.js';
+import {} from './machine.js';
+// Fire and forget: never longer than this, never a failure, silent unless AGENTAGE_DEBUG=1.
+const BUDGET_MS = 2_000;
+const NAME_MAX = 128;
+const routeOf = (id) => `/v1/machines/${id}`;
+const debug = (text) => {
+    if (process.env['AGENTAGE_DEBUG'] === '1')
+        console.error(`machines: ${text}`);
+};
+// A 404's body is read for its code; any other body is dropped unread.
+const answerOf = async (res) => {
+    if (res.status === 404)
+        return { status: 404, code: await errorCode(res) };
+    await res.body?.cancel();
+    return { status: res.status, code: null };
+};
+// What the account answered, or null when it did not.
+const send = async (fetch, call, timeoutMs = BUDGET_MS) => {
+    const headers = call.body ? { 'content-type': 'application/json' } : {};
+    const body = call.body ? JSON.stringify(call.body) : undefined;
+    try {
+        const answer = await answerOf(await fetch(call.path, { method: call.method, headers, body, timeoutMs }));
+        debug(`${call.method} ${call.path} ${answer.status}${answer.code ? ` ${answer.code}` : ''}`);
+        return answer;
+    }
+    catch (err) {
+        const reason = err.name === 'TimeoutError' ? 'timed out' : err.message;
+        debug(`${call.method} ${call.path} failed: ${reason}`);
+        return null;
+    }
+};
+const registration = (machine) => ({
+    name: machine.name.slice(0, NAME_MAX),
+    platform: `${process.platform}-${process.arch}`,
+    cliVersion: VERSION,
+    state: 'connected',
+});
+// Signed-in setup: create or refresh the record, then mark it seen, both inside one budget.
+export const registerMachine = async (fetch, machine) => {
+    const deadline = Date.now() + BUDGET_MS;
+    const path = routeOf(machine.id);
+    await send(fetch, { method: 'PUT', path, body: registration(machine) });
+    await send(fetch, { method: 'POST', path: `${path}/seen` }, Math.max(1, deadline - Date.now()));
+};
+// true when the account knows this machine, false on MACHINE_NOT_FOUND, null when it did not
+// say: any other 404 is an API without the route, as unknown as no answer.
+export const seenMachine = async (fetch, id) => {
+    const answer = await send(fetch, { method: 'POST', path: `${routeOf(id)}/seen` });
+    if (answer?.code === 'MACHINE_NOT_FOUND')
+        return false;
+    return answer !== null && answer.status >= 200 && answer.status < 300 ? true : null;
+};
+export const disconnectMachine = async (fetch, id) => {
+    await send(fetch, { method: 'PATCH', path: routeOf(id), body: { state: 'disconnected' } });
+};

package/dist/core/profile/schema.d.ts

@@ -0,0 +1,28 @@
+export declare const SCHEMA_VERSION = 1;
+export type ConfigMap = Record<string, Record<string, unknown>>;
+export interface MachineEntry {
+    off: string[];
+    config: ConfigMap;
+    extra: Record<string, unknown>;
+}
+export interface Profile {
+    version: number;
+    extensions: Record<string, string>;
+    registries: Record<string, string>;
+    config: ConfigMap;
+    machines: Record<string, MachineEntry>;
+    extra: Record<string, unknown>;
+}
+export type ProfileParse = {
+    ok: true;
+    profile: Profile;
+    readOnly: boolean;
+    warnings: string[];
+} | {
+    ok: false;
+    errors: string[];
+};
+export declare const PACKAGE_NAME: RegExp;
+export declare const specProblem: (spec: string) => string | null;
+export declare const parseProfile: (doc: unknown) => ProfileParse;
+export declare const toDocument: (profile: Profile) => Record<string, unknown>;

package/dist/core/profile/schema.js

@@ -0,0 +1,165 @@
+import { isRecord } from '../../lib/fs/json-file.js';
+import { isRange } from '../semver-range.js';
+export const SCHEMA_VERSION = 1;
+const TOP_KEYS = ['version', 'extensions', 'registries', 'config', 'machines'];
+const MACHINE_KEYS = ['off', 'config'];
+export const PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/;
+const SCOPE = /^@[a-z0-9][a-z0-9._~-]*$/;
+const LOOPBACK_HOST = /^(?:localhost|.+\.localhost|127(?:\.\d{1,3}){3}|0\.0\.0\.0|\[::1?\])$/i;
+const REFUSED_PREFIX = /^(npm|github|file|http):/i;
+const OTHER_PROTOCOL = /^[a-z][a-z0-9+.-]*:/i;
+const LOCAL_PATH = /^(?:\.{1,2}[/\\]|~?[/\\])/;
+const EMPTY_MACHINE = { off: [], config: {}, extra: {} };
+const USE_INSTEAD = 'use a semver range or an https: tarball URL';
+const at = (name) => `[${JSON.stringify(name)}]`;
+const fail = (issues, message, fallback) => {
+    issues.errors.push(message);
+    return fallback;
+};
+const urlOf = (text) => {
+    try {
+        return new URL(text);
+    }
+    catch {
+        return null;
+    }
+};
+const httpsProblem = (spec) => {
+    const url = urlOf(spec);
+    if (url === null)
+        return 'is not a valid https: URL';
+    return LOOPBACK_HOST.test(url.hostname) ? 'loopback URLs are refused' : null;
+};
+export const specProblem = (spec) => {
+    const refused = REFUSED_PREFIX.exec(spec)?.[1];
+    if (refused)
+        return `${refused.toLowerCase()}: specs are refused; ${USE_INSTEAD}`;
+    if (/^https:/i.test(spec))
+        return httpsProblem(spec);
+    if (LOCAL_PATH.test(spec))
+        return 'local paths are dev-only and belong in machine.json';
+    if (OTHER_PROTOCOL.test(spec))
+        return `unsupported spec; ${USE_INSTEAD}`;
+    return isRange(spec) ? null : `is not a semver range; ${USE_INSTEAD}`;
+};
+const extensionProblem = (name, spec) => {
+    if (!PACKAGE_NAME.test(name))
+        return 'is not a valid package name';
+    if (typeof spec !== 'string' || spec.trim() === '')
+        return 'must be a non-empty string';
+    return specProblem(spec.trim());
+};
+// Whitespace is refused outright: the URL lands on one line of the tree's .npmrc.
+const registryProblem = (scope, url) => {
+    if (!SCOPE.test(scope))
+        return 'is not an npm scope (@name)';
+    const parsed = typeof url === 'string' && !/\s/.test(url) ? urlOf(url) : null;
+    if (parsed && (parsed.username || parsed.password))
+        return 'must not carry credentials';
+    if (parsed?.protocol === 'https:')
+        return null;
+    if (parsed?.protocol === 'http:' && LOOPBACK_HOST.test(parsed.hostname))
+        return null;
+    return 'must be an https: URL, or http: on a loopback host';
+};
+// A map of strings: each entry is checked on its own and reported by its path.
+const parseMap = (value, path, problemOf, issues) => {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        return fail(issues, `${path}: must be an object`, {});
+    const map = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const problem = problemOf(key, entry);
+        if (problem)
+            issues.errors.push(`${path}${at(key)}: ${problem}`);
+        else
+            map[key] = String(entry);
+    }
+    return map;
+};
+const parseConfig = (value, path, issues) => {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        return fail(issues, `${path}: must be an object`, {});
+    const config = {};
+    for (const [id, slice] of Object.entries(value)) {
+        if (isRecord(slice))
+            config[id] = slice;
+        else
+            issues.errors.push(`${path}${at(id)}: must be an object`);
+    }
+    return config;
+};
+const extraKeys = (doc, known, path, issues) => {
+    const extra = Object.fromEntries(Object.entries(doc).filter(([key]) => !known.includes(key)));
+    for (const key of Object.keys(extra))
+        issues.warnings.push(`${path}: unknown key "${key}" kept`);
+    return extra;
+};
+const parseOff = (value, path, issues) => {
+    if (value === undefined)
+        return [];
+    if (Array.isArray(value) && value.every((name) => typeof name === 'string'))
+        return value;
+    return fail(issues, `${path}.off: must be an array of package names`, []);
+};
+const parseMachine = (value, path, issues) => {
+    if (!isRecord(value))
+        return fail(issues, `${path}: must be an object`, EMPTY_MACHINE);
+    return {
+        off: parseOff(value['off'], path, issues),
+        config: parseConfig(value['config'], `${path}.config`, issues),
+        extra: extraKeys(value, MACHINE_KEYS, path, issues),
+    };
+};
+const parseMachines = (value, issues) => {
+    if (value === undefined)
+        return {};
+    if (!isRecord(value))
+        return fail(issues, 'machines: must be an object', {});
+    return Object.fromEntries(Object.entries(value).map(([id, entry]) => [
+        id,
+        parseMachine(entry, `machines${at(id)}`, issues),
+    ]));
+};
+const parseVersionField = (value, issues) => {
+    if (typeof value === 'number' && Number.isInteger(value) && value >= 1)
+        return value;
+    const got = value === undefined ? 'missing' : JSON.stringify(value);
+    issues.errors.push(`version: must be ${SCHEMA_VERSION} (got ${got})`);
+    return SCHEMA_VERSION;
+};
+const readOnlyWarning = (version) => `version: ${version} is newer than this CLI understands (${SCHEMA_VERSION}); read-only`;
+export const parseProfile = (doc) => {
+    if (!isRecord(doc))
+        return { ok: false, errors: ['profile.json: must be a JSON object'] };
+    const issues = { errors: [], warnings: [] };
+    const profile = {
+        version: parseVersionField(doc['version'], issues),
+        extensions: parseMap(doc['extensions'], 'extensions', extensionProblem, issues),
+        registries: parseMap(doc['registries'], 'registries', registryProblem, issues),
+        config: parseConfig(doc['config'], 'config', issues),
+        machines: parseMachines(doc['machines'], issues),
+        extra: extraKeys(doc, TOP_KEYS, 'profile.json', issues),
+    };
+    if (issues.errors.length > 0)
+        return { ok: false, errors: issues.errors };
+    const readOnly = profile.version > SCHEMA_VERSION;
+    if (readOnly)
+        issues.warnings.push(readOnlyWarning(profile.version));
+    return { ok: true, profile, readOnly, warnings: issues.warnings };
+};
+// The inverse of parseProfile: unknown keys go back where they were found.
+export const toDocument = (profile) => ({
+    version: profile.version,
+    extensions: profile.extensions,
+    ...(Object.keys(profile.registries).length > 0 ? { registries: profile.registries } : {}),
+    config: profile.config,
+    machines: Object.fromEntries(Object.entries(profile.machines).map(([id, m]) => [
+        id,
+        { off: m.off, config: m.config, ...m.extra },
+    ])),
+    ...profile.extra,
+});

package/dist/core/semver-range.d.ts

@@ -0,0 +1,17 @@
+interface Version {
+    major: number;
+    minor: number;
+    patch: number;
+    pre: string | null;
+}
+type Op = '<' | '<=' | '>' | '>=' | '=';
+interface Comparator {
+    op: Op;
+    v: Version;
+}
+export declare const parseVersion: (text: string) => Version | null;
+export declare const parseRange: (range: string) => Comparator[][] | null;
+export declare const isRange: (range: string) => boolean;
+export declare const satisfies: (version: string, range: string) => boolean;
+export declare const newestFirst: (a: string, b: string) => number;
+export {};

package/dist/core/semver-range.js

@@ -0,0 +1,124 @@
+const WILD = /^[xX*]$/;
+const VERSION_RE = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+const PARTIAL_RE = /^v?(\d+|[xX*])(?:\.(\d+|[xX*]))?(?:\.(\d+|[xX*]))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+const COMPARATOR_RE = /^(\^|~|>=|<=|>|<|=)?(.+)$/;
+const ver = (major, minor, patch, pre = null) => ({
+    major,
+    minor,
+    patch,
+    pre,
+});
+export const parseVersion = (text) => {
+    const m = VERSION_RE.exec(text.trim());
+    if (!m)
+        return null;
+    return ver(Number(m[1]), Number(m[2]), Number(m[3]), m[4] ?? null);
+};
+const parsePartial = (text) => {
+    const m = PARTIAL_RE.exec(text);
+    if (!m)
+        return null;
+    const raw = [m[1], m[2], m[3]];
+    const nums = [];
+    for (const part of raw) {
+        if (part === undefined || WILD.test(part))
+            break;
+        nums.push(Number(part));
+    }
+    const concreteAfterWild = raw.slice(nums.length).some((p) => p !== undefined && !WILD.test(p));
+    if (concreteAfterWild || (m[4] !== undefined && nums.length < 3))
+        return null;
+    return { nums, pre: m[4] ?? null };
+};
+const lower = (p) => ver(p.nums[0] ?? 0, p.nums[1] ?? 0, p.nums[2] ?? 0, p.pre);
+// Exclusive upper bound one step above part `i`; the `-0` keeps that version's prereleases out.
+const bump = (p, i) => {
+    const [a = 0, b = 0, c = 0] = p.nums;
+    if (i <= 0)
+        return ver(a + 1, 0, 0, '0');
+    return i === 1 ? ver(a, b + 1, 0, '0') : ver(a, b, c + 1, '0');
+};
+const span = (p, i) => [
+    { op: '>=', v: lower(p) },
+    { op: '<', v: bump(p, i) },
+];
+const exact = (p) => p.nums.length === 3 ? [{ op: '=', v: lower(p) }] : span(p, p.nums.length - 1);
+const caretIndex = (nums) => {
+    const i = nums.findIndex((n) => n !== 0);
+    return i === -1 ? nums.length - 1 : i;
+};
+const bounded = (op, p) => {
+    const n = p.nums.length;
+    if (op === '>=')
+        return [{ op, v: lower(p) }];
+    if (op === '>')
+        return n === 3 ? [{ op, v: lower(p) }] : [{ op: '>=', v: bump(p, n - 1) }];
+    if (op === '<')
+        return [{ op, v: n === 3 ? lower(p) : { ...lower(p), pre: '0' } }];
+    return n === 3 ? [{ op, v: lower(p) }] : [{ op: '<', v: bump(p, n - 1) }];
+};
+const desugar = (op, p) => {
+    if (p.nums.length === 0)
+        return op === '>' || op === '<' ? null : [];
+    if (op === undefined || op === '=')
+        return exact(p);
+    if (op === '~')
+        return span(p, Math.min(p.nums.length - 1, 1));
+    if (op === '^')
+        return span(p, caretIndex(p.nums));
+    return bounded(op, p);
+};
+const parseComparator = (token) => {
+    const m = COMPARATOR_RE.exec(token);
+    const partial = m?.[2] === undefined ? null : parsePartial(m[2]);
+    return m && partial ? desugar(m[1], partial) : null;
+};
+const parseSet = (set) => {
+    const tokens = set
+        .replace(/(\^|~|>=|<=|>|<|=)\s+/g, '$1')
+        .trim()
+        .split(/\s+/);
+    if (tokens.length === 0 || tokens[0] === '')
+        return null;
+    const parsed = tokens.map(parseComparator);
+    return parsed.some((c) => c === null) ? null : parsed.flatMap((c) => c ?? []);
+};
+export const parseRange = (range) => {
+    const sets = range.split('||').map(parseSet);
+    return sets.some((s) => s === null) ? null : sets.map((s) => s ?? []);
+};
+export const isRange = (range) => parseRange(range) !== null;
+// Prereleases sort below their release, compared as plain strings (no identifier splitting).
+const comparePre = (a, b) => {
+    if (a === b)
+        return 0;
+    if (a === null || b === null)
+        return a === null ? 1 : -1;
+    return a < b ? -1 : 1;
+};
+const compareVersions = (a, b) => a.major - b.major || a.minor - b.minor || a.patch - b.patch || comparePre(a.pre, b.pre);
+const holds = (c, v) => {
+    const d = compareVersions(v, c.v);
+    if (c.op === '=')
+        return d === 0;
+    if (c.op === '<')
+        return d < 0;
+    if (c.op === '<=')
+        return d <= 0;
+    return c.op === '>' ? d > 0 : d >= 0;
+};
+export const satisfies = (version, range) => {
+    const v = parseVersion(version);
+    const sets = parseRange(range);
+    if (!v || !sets)
+        return false;
+    return sets.some((set) => set.every((c) => holds(c, v)));
+};
+// For sort(): newest version first; text that is not a version goes last.
+export const newestFirst = (a, b) => {
+    const x = parseVersion(a);
+    const y = parseVersion(b);
+    if (x && y)
+        return compareVersions(y, x);
+    return (x ? -1 : 0) + (y ? 1 : 0);
+};

package/dist/extension-test.d.ts

@@ -0,0 +1,7 @@
+import { Command } from 'commander';
+import { type ExtensionApi, type ExtensionContext } from './extension.js';
+export interface TestContextOverrides extends Partial<Omit<ExtensionContext, 'mode' | 'use'>> {
+    use?: Record<string, ExtensionApi>;
+    program?: Command;
+}
+export declare const createTestContext: (overrides?: TestContextOverrides) => ExtensionContext;

package/dist/extension-test.js

@@ -0,0 +1,49 @@
+/**
+ * The `@agentage/cli/extension/test` subpath export: `createTestContext` builds the `ctx` an
+ * extension's own unit tests hand to its `register`, over a temp dir, with `use` from fakes.
+ */
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Command } from 'commander';
+import {} from './extension.js';
+const memorySecrets = () => {
+    const values = new Map();
+    return {
+        get: async (key) => values.get(key),
+        set: async (key, value) => void values.set(key, value),
+        delete: async (key) => void values.delete(key),
+    };
+};
+const fakeUse = (fakes) => ((id, options = {}) => {
+    const fake = fakes[id];
+    if (fake !== undefined || options.optional)
+        return fake;
+    throw new Error(`use("${id}"): no fake for it in createTestContext({ use })`);
+});
+// A fresh temp dir per context, laid out like the CLI's config dir.
+const folders = (id) => {
+    const root = mkdtempSync(join(tmpdir(), 'agentage-test-'));
+    return { data: join(root, 'data', id), cache: join(root, 'cache', id) };
+};
+// Same members, in the same order, as the ctx the CLI builds; mode is always 'test'.
+export const createTestContext = (overrides = {}) => {
+    const { use = {}, program = new Command('agentage'), config = {}, ...rest } = overrides;
+    const id = rest.id ?? 'test';
+    const subscriptions = [];
+    const ctx = {
+        id,
+        version: '0.0.0',
+        previousVersion: null,
+        mode: 'test',
+        config: Object.freeze({ ...config }),
+        secrets: memorySecrets(),
+        ...folders(id),
+        log: () => undefined,
+        commands: { add: (...registrars) => registrars.forEach((register) => register(program)) },
+        use: fakeUse(use),
+        subscriptions: { push: (...items) => void subscriptions.push(...items) },
+        ...rest,
+    };
+    return Object.freeze(ctx);
+};

package/dist/extension.d.ts

@@ -0,0 +1,83 @@
+import { type Command } from 'commander';
+export declare const EXTENSION_API_VERSION = "1.0.0";
+export type ConfigType = 'string' | 'number' | 'boolean' | 'array' | 'object';
+export interface ConfigurationEntry {
+    type: ConfigType;
+    default?: unknown;
+    description?: string;
+    enum?: unknown[];
+    secret?: boolean;
+    scope?: 'shared' | 'machine';
+}
+export interface ExtensionManifest {
+    name: string;
+    version: string;
+    keywords?: string[];
+    engines?: {
+        agentage?: string;
+    };
+    peerDependencies?: Record<string, string>;
+    peerDependenciesMeta?: Record<string, {
+        optional?: boolean;
+    }>;
+    agentage: {
+        id: string;
+        contributes?: {
+            commands?: string[];
+        };
+        configuration?: Record<string, ConfigurationEntry>;
+    };
+}
+export interface Disposable {
+    dispose: () => void | Promise<void>;
+}
+export type ExtensionApi = Readonly<Record<string, (...args: never[]) => unknown>>;
+export interface ExtensionApis {
+}
+export interface ExtensionUse {
+    <K extends keyof ExtensionApis>(id: K, options?: {
+        optional?: false;
+    }): ExtensionApis[K];
+    <K extends keyof ExtensionApis>(id: K, options: {
+        optional: true;
+    }): ExtensionApis[K] | undefined;
+    (id: string, options?: {
+        optional?: false;
+    }): ExtensionApi;
+    (id: string, options: {
+        optional: true;
+    }): ExtensionApi | undefined;
+}
+export interface ExtensionSecrets {
+    get: (key: string) => Promise<string | undefined>;
+    set: (key: string, value: string) => Promise<void>;
+    delete: (key: string) => Promise<void>;
+}
+export type ExtensionLog = (message: string, fields?: Record<string, unknown>) => void;
+export type CommandRegistrar = (program: Command) => void;
+export interface ExtensionCommands {
+    add: (...registrars: CommandRegistrar[]) => void;
+}
+export interface ExtensionSubscriptions {
+    push: (...disposables: Disposable[]) => void;
+}
+export type ExtensionMode = 'installed' | 'dev' | 'test';
+export interface ExtensionContext {
+    readonly id: string;
+    readonly version: string;
+    readonly previousVersion: string | null;
+    readonly mode: ExtensionMode;
+    readonly config: Readonly<Record<string, unknown>>;
+    readonly secrets: ExtensionSecrets;
+    readonly data: string;
+    readonly cache: string;
+    readonly log: ExtensionLog;
+    readonly commands: ExtensionCommands;
+    readonly use: ExtensionUse;
+    readonly subscriptions: ExtensionSubscriptions;
+}
+export type Register = (ctx: ExtensionContext) => ExtensionApi | void | Promise<ExtensionApi | void>;
+export interface Extension {
+    register: Register;
+}
+export declare const defineExtension: <T extends Extension>(extension: T) => T;

package/dist/extension.js

@@ -0,0 +1,6 @@
+// Types for an extension's entry; at runtime an extension gets everything through ctx, never this.
+import {} from 'commander';
+// The extension contract is versioned apart from the CLI, so extensions pin it, not a CLI release.
+export const EXTENSION_API_VERSION = '1.0.0';
+// Identity at runtime: it only gives an entry its types.
+export const defineExtension = (extension) => extension;

package/dist/lib/auth/api.d.ts

@@ -1,8 +1,8 @@
 import { type AuthState } from '../fs/config.js';
-import { type CliRequestInit } from '../net/fetch.js';
+import { type CliFetchOptions, type CliRequestInit } from '../net/fetch.js';
 import { type Links } from '../net/origins.js';
 export { AuthRequiredError, TransientAuthError } from './auth-errors.js';
 export declare const refreshOrThrow: (auth: AuthState, links: Links) => Promise<void>;
-export declare const authedFetch: (auth: AuthState, links: Links, url: string, init?: CliRequestInit) => Promise<Response>;
+export declare const authedFetch: (auth: AuthState, links: Links, url: string, init?: CliRequestInit, opts?: CliFetchOptions) => Promise<Response>;
 export declare const authedJson: <T>(auth: AuthState, links: Links, url: string, init?: CliRequestInit) => Promise<T>;
 export { introspectToken, type TokenSession } from './introspect.js';

package/dist/lib/auth/api.js

@@ -61,12 +61,12 @@ const withBearer = (auth, init) => ({
     headers: { ...init.headers, authorization: `Bearer ${auth.tokens.accessToken}` },
 });
 // The raw Response after at most one refresh-and-retry on 401; callers branch on the status.
-export const authedFetch = async (auth, links, url, init = {}) => {
-    const res = await cliFetch(url, withBearer(auth, init));
+export const authedFetch = async (auth, links, url, init = {}, opts = {}) => {
+    const res = await cliFetch(url, withBearer(auth, init), opts);
     if (res.status !== 401 || !(await tryRefresh(auth, links)))
         return res;
     await res.body?.cancel();
-    return cliFetch(url, withBearer(auth, init));
+    return cliFetch(url, withBearer(auth, init), opts);
 };
 export const authedJson = async (auth, links, url, init = {}) => {
     const method = init.method ?? 'GET';

package/dist/lib/auth/callback-page.d.ts

@@ -0,0 +1,2 @@
+export declare const escapeHtml: (text: string) => string;
+export declare const callbackPage: (ok: boolean, detail: string) => string;

package/dist/lib/auth/callback-page.js

@@ -0,0 +1,40 @@
+// The one page the CLI ever serves: the sign-in result, on the design-system dark tokens.
+const LOGO = 'M143.8 33.7a13.2 13.2 0 00-23.6 0l-92.4 184.8a13.2 13.2 0 0015.4 18.6l66-18.9a13.2 13.2 0 ' +
+    '009.5-12.7v-60.3a13.2 13.2 0 1126.4 0v60.3a13.2 13.2 0 009.6 12.7l66 18.9a13.2 13.2 0 ' +
+    '0015.4-18.6l-92.3-184.8z';
+const STYLE = `
+*{margin:0;padding:0;box-sizing:border-box}
+html{color-scheme:dark}
+body{background:oklch(0.085 0.013 277);color:oklch(0.97 0.003 277);
+font-family:system-ui,-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;
+-webkit-font-smoothing:antialiased;min-height:100vh;display:grid;place-items:center;padding:24px}
+.card{background:oklch(0.17 0.018 277);border:1px solid oklch(0.237 0.017 277);border-radius:.75rem;
+padding:40px 32px;width:100%;max-width:400px;text-align:center;
+box-shadow:0 10px 15px -3px oklch(0 0 0/.1),0 4px 6px -4px oklch(0 0 0/.1)}
+.brand{display:inline-flex;align-items:center;gap:10px;margin-bottom:28px;font-weight:600;font-size:1rem}
+.brand svg{width:28px;height:28px}
+.icon{width:48px;height:48px;border-radius:9999px;margin:0 auto 20px;display:grid;place-items:center}
+.ok .icon{background:oklch(0.723 0.191 149.6/.15);color:oklch(0.723 0.191 149.6)}
+.err .icon{background:oklch(0.628 0.208 25.6/.15);color:oklch(0.628 0.208 25.6)}
+h1{font-size:1.25rem;font-weight:600;letter-spacing:-.02em;margin-bottom:8px}
+p{color:oklch(0.59 0.014 256);font-size:.875rem;line-height:1.5}
+.hint{margin-top:24px;font-size:.75rem;color:oklch(0.59 0.014 256)}
+`;
+const ICON = {
+    ok: '<svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="M20 6 9 17l-5-5"/></svg>',
+    err: '<svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"><path d="M18 6 6 18M6 6l12 12"/></svg>',
+};
+const ESCAPES = { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' };
+// The error text comes from the authorization server's redirect: never trust it as markup.
+export const escapeHtml = (text) => text.replace(/[&<>"]/g, (c) => ESCAPES[c] ?? c);
+export const callbackPage = (ok, detail) => {
+    const kind = ok ? 'ok' : 'err';
+    const title = ok ? 'Signed in' : 'Sign-in failed';
+    const hint = ok ? 'You can close this tab.' : 'Run agentage setup again to retry.';
+    return (`<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">` +
+        `<title>${title} - agentage</title><style>${STYLE}</style></head><body><main class="card ${kind}">` +
+        `<div class="brand"><svg viewBox="0 0 416 416" aria-hidden="true"><rect width="416" height="416" rx="83" fill="#f3a52b"/>` +
+        `<g transform="translate(25.7 25.7) scale(1.3812)"><path d="${LOGO}" fill="#000"/></g></svg>agentage</div>` +
+        `<div class="icon">${ICON[kind]}</div><h1>${title}</h1><p>${escapeHtml(detail)}</p>` +
+        `<p class="hint">${hint}</p></main></body></html>`);
+};

package/dist/lib/auth/callback-server.js

@@ -1,8 +1,5 @@
 import { createServer } from 'node:http';
-const page = (ok, detail) => '<!doctype html><html><head><meta charset="utf-8"><title>agentage</title></head>' +
-    '<body style="font-family:system-ui;display:grid;place-items:center;min-height:80vh">' +
-    `<div style="text-align:center"><h1>${ok ? 'Signed in' : 'Sign-in failed'}</h1>` +
-    `<p>${detail}</p></div></body></html>`;
+import { callbackPage as page } from './callback-page.js';
 export const startCallbackServer = (expectedState) => new Promise((resolveServer) => {
     let settle = null;
     let result = null;

package/dist/lib/fs/file-lock.d.ts

@@ -2,7 +2,9 @@ export interface LockOptions {
     ttlMs?: number;
     hardStaleMs?: number;
     maxWaitMs?: number;
+    onWait?: () => void;
 }
 export declare const acquireFileLock: (target: string, now?: number, opts?: LockOptions) => boolean;
 export declare const releaseFileLock: (target: string) => void;
-export declare const withFileLock: <T>(target: string, fn: () => T, opts?: LockOptions) => Promise<T>;
+export declare const refreshFileLock: (target: string, now?: number) => boolean;
+export declare const withFileLock: <T>(target: string, fn: () => T | Promise<T>, opts?: LockOptions) => Promise<T>;