@cortexkit/opencode-antigravity-auth 3.0.5 → 3.0.6

package/dist/src/common-auth-embedded/quota/map.js

@@ -83,6 +83,40 @@ export function isCreditBudgetEntry(value) {
         optional(value, 'remaining', isFiniteNumber) &&
         optional(value, 'unit', isString));
 }
+function isQuotaCounter(value) {
+    return (isRecord(value) &&
+        isFiniteNumber(value.value) &&
+        Number.isInteger(value.value) &&
+        value.value >= 0 &&
+        isFiniteNumber(value.checkedAt));
+}
+export function isQuotaCounters(value) {
+    return isRecord(value) && Object.values(value).every(isQuotaCounter);
+}
+/** Keep usable counters without letting one malformed count hide a quota map. */
+export function readQuotaCounters(value) {
+    if (!isRecord(value))
+        return undefined;
+    const entries = Object.entries(value).filter(([, entry]) => isQuotaCounter(entry));
+    return entries.length === 0
+        ? undefined
+        : Object.fromEntries(entries);
+}
+/** Decode persisted quota, dropping malformed counters but not limit evidence. */
+export function decodeQuotaMap(value) {
+    // A valid map is returned as the same object, so stored quota keeps the
+    // identity it had before counters existed; only a map with a malformed
+    // counter is copied without it.
+    if (isQuotaMap(value))
+        return value;
+    if (!isRecord(value))
+        return undefined;
+    const { counters: rawCounters, ...rest } = value;
+    if (!isQuotaMap(rest))
+        return undefined;
+    const counters = readQuotaCounters(rawCounters);
+    return { ...rest, ...(counters === undefined ? {} : { counters }) };
+}
 /**
  * True when `value` is a well-formed quota map. Unrecognised top-level keys
  * are tolerated (and preserved by merge) so a newer writer's additions
@@ -101,5 +135,6 @@ export function isQuotaMap(value) {
             return false;
         seen.add(key);
     }
-    return optional(value, 'budget', isCreditBudgetEntry);
+    return (optional(value, 'budget', isCreditBudgetEntry) &&
+        optional(value, 'counters', isQuotaCounters));
 }

package/dist/src/common-auth-embedded/quota/merge.d.ts

@@ -1,4 +1,4 @@
-import { type QuotaMap } from './map.js';
+import { type QuotaCounter, type QuotaMap } from './map.js';
 export interface ObservedReading {
     /** Defaults to `all`. */
     scope?: string;
@@ -32,6 +32,8 @@ export interface QuotaObservation {
     coverage?: ObservedPair[];
     /** Absent means the observation says nothing about the budget. */
     budget?: ObservedBudget;
+    /** Each named count uses its own time, independently of limits and budget. */
+    counters?: Record<string, QuotaCounter>;
 }
 /** Thrown by `mergeQuotaObservation` when either argument is malformed. */
 export declare class QuotaCodecError extends TypeError {

package/dist/src/common-auth-embedded/quota/merge.js

@@ -11,7 +11,7 @@
 // no entry gets an absence record. A pair outside the coverage is never
 // touched, so a header-shaped partial observation (which covers only what it
 // carries) cannot erase a family limit or the budget.
-import { ALL_SCOPE, entryTime, isQuotaMap, limitKey, } from './map.js';
+import { ALL_SCOPE, decodeQuotaMap, entryTime, isQuotaCounters, limitKey, } from './map.js';
 /** Thrown by `mergeQuotaObservation` when either argument is malformed. */
 export class QuotaCodecError extends TypeError {
     constructor(message) {
@@ -83,7 +83,8 @@ export function isQuotaObservation(value) {
     }
     if (!coverage.every(isObservedPair))
         return false;
-    return value.budget === undefined || isObservedBudget(value.budget);
+    return ((value.budget === undefined || isObservedBudget(value.budget)) &&
+        (value.counters === undefined || isQuotaCounters(value.counters)));
 }
 function compareEntries(left, right) {
     if (left.scope !== right.scope)
@@ -99,6 +100,16 @@ function mergeBudget(stored, observed, checkedAt) {
         return stored;
     return { ...observed, checkedAt };
 }
+function mergeCounters(stored, observed) {
+    const counters = new Map(Object.entries(stored ?? {}));
+    for (const [name, counter] of Object.entries(observed ?? {})) {
+        const existing = counters.get(name);
+        if (existing === undefined || counter.checkedAt >= existing.checkedAt) {
+            counters.set(name, counter);
+        }
+    }
+    return counters.size === 0 ? undefined : Object.fromEntries(counters);
+}
 /**
  * Applies `observation` to `stored` (undefined for a row with no map yet) and
  * returns the new map. Pure: neither argument is modified. Throws
@@ -106,13 +117,16 @@ function mergeBudget(stored, observed, checkedAt) {
  * write rather than persisting a map it could not read back.
  */
 export function mergeQuotaObservation(stored, observation) {
-    if (stored !== undefined && !isQuotaMap(stored)) {
+    // Decode the stored map the way reads do, so a malformed counter that reads
+    // already hide is dropped here too instead of refusing every later write.
+    const decoded = stored === undefined ? undefined : decodeQuotaMap(stored);
+    if (stored !== undefined && decoded === undefined) {
         throw new QuotaCodecError('stored quota map is malformed');
     }
     if (!isQuotaObservation(observation)) {
         throw new QuotaCodecError('quota observation is malformed');
     }
-    const base = stored ?? { limits: [] };
+    const base = decoded ?? { limits: [] };
     const at = observation.checkedAt;
     const entries = new Map();
     for (const entry of base.limits) {
@@ -152,11 +166,13 @@ export function mergeQuotaObservation(stored, observation) {
             : { scope, label: pair.label, kind: 'retired', retiredAt: at });
     }
     // Keys this module does not recognise are carried over untouched.
-    const { limits: _limits, budget: _budget, ...unknownKeys } = base;
+    const { limits: _limits, budget: _budget, counters: _counters, ...unknownKeys } = base;
     const budget = mergeBudget(base.budget, observation.budget, at);
+    const counters = mergeCounters(base.counters, observation.counters);
     return {
         ...unknownKeys,
         limits: [...entries.values()].sort(compareEntries),
         ...(budget === undefined ? {} : { budget }),
+        ...(counters === undefined ? {} : { counters }),
     };
 }

package/dist/src/common-auth-embedded/quota/projection.d.ts

@@ -1,4 +1,4 @@
-import { type QuotaMap } from './map.js';
+import { type QuotaCounter, type QuotaMap } from './map.js';
 export interface ProjectedLimit {
     scope: string;
     label: string;
@@ -30,6 +30,7 @@ export interface ProjectedQuota {
     checkedAt?: number;
     /** Present only when the stored budget is a reading, not cleared. */
     budget?: ProjectedBudget;
+    counters?: Record<string, QuotaCounter>;
 }
 /**
  * Resolves `map` for a request in `scope` (`all` or a model family). A family

package/dist/src/common-auth-embedded/quota/projection.js

@@ -6,7 +6,7 @@
 // scope, orders the result the way the primitives expect, and carries each
 // entry's (scope, label) so a decision names the limit it judged rather than
 // the position it occupied.
-import { ALL_SCOPE, } from './map.js';
+import { ALL_SCOPE, readQuotaCounters, } from './map.js';
 function project(entry) {
     if (entry.kind === 'retired') {
         return {
@@ -94,11 +94,13 @@ export function projectQuota(map, scope = ALL_SCOPE) {
         ? Math.min(...stamped.map((limit) => limit.checkedAt))
         : undefined;
     const budget = map?.budget?.kind === 'reading' ? projectBudget(map.budget) : undefined;
+    const counters = readQuotaCounters(map?.counters);
     return {
         scope,
         limits,
         ...(checkedAt === undefined ? {} : { checkedAt }),
         ...(budget === undefined ? {} : { budget }),
+        ...(counters === undefined ? {} : { counters }),
     };
 }
 /**

package/dist/src/common-auth-embedded/setup/command-runner.js

@@ -0,0 +1,49 @@
+import { execFile } from 'node:child_process';
+export const defaultCommandRunner = {
+    run(file, args, options = {}) {
+        return new Promise((resolve) => {
+            const started = performance.now();
+            const timeoutMs = options.timeoutMs ?? 15_000;
+            execFile(file, [...args], {
+                env: options.env ?? process.env,
+                timeout: timeoutMs,
+                windowsHide: true,
+                windowsVerbatimArguments: options.windowsVerbatimArguments,
+                maxBuffer: 1024 * 1024,
+            }, (error, stdout, stderr) => {
+                const durationMs = performance.now() - started;
+                resolve({
+                    exitCode: error
+                        ? typeof error.code === 'number'
+                            ? error.code
+                            : 1
+                        : 0,
+                    stdout: String(stdout ?? ''),
+                    stderr: String(stderr ?? ''),
+                    signal: error?.signal ?? null,
+                    // Buffer-limit and spawn errors have string codes, not timeout kills.
+                    timedOut: error?.killed === true &&
+                        typeof error.code !== 'string' &&
+                        error.signal === 'SIGTERM' &&
+                        durationMs >= timeoutMs &&
+                        timeoutMs > 0,
+                    durationMs,
+                });
+            });
+        });
+    },
+};
+/** Batch launchers need cmd.exe; no free-form user text is accepted as shell arguments. */
+export function runResolvedCommand(runner, platform, file, args, env, timeoutMs = 15_000) {
+    if (platform === 'win32' && /\.(cmd|bat)$/i.test(file)) {
+        if (/["%!\r\n]/.test(file) ||
+            args.some((arg) => !/^[a-zA-Z0-9@:/._+-]+$/.test(arg)))
+            throw new Error('Unsafe batch launcher or argument; use an executable instead.');
+        return runner.run('cmd.exe', ['/d', '/s', '/c', `""${file}" ${args.join(' ')}"`], {
+            env,
+            timeoutMs,
+            windowsVerbatimArguments: true,
+        });
+    }
+    return runner.run(file, args, { env, timeoutMs });
+}

package/dist/src/common-auth-embedded/setup/command.d.ts

@@ -0,0 +1,3 @@
+import type { SetupIO, SetupPlugin, SetupResult } from './types.js';
+export declare const AMBIGUOUS_OPENCODE_MESSAGE = "Multiple OpenCode generations found. Choose --opencode=1|2|both before running noninteractive setup.";
+export declare function runSetup(plugin: SetupPlugin, argv?: readonly string[], io?: SetupIO): Promise<SetupResult>;

package/dist/src/common-auth-embedded/setup/command.js

@@ -0,0 +1,215 @@
+import { select } from '../auth-menu/select.js';
+import { isInteractive, printLine, processTerminal, } from '../auth-menu/terminal.js';
+import { hostEnrollmentPaths } from '../claustrum/enrollment.js';
+import { defaultCommandRunner } from './command-runner.js';
+import { detectHosts } from './detect.js';
+import { connectSetupHost } from './enroll.js';
+import { setupPaths } from './paths.js';
+import { assertHostsStopped, createProcessFence, ProcessFenceViolationError, ProcessInspectionError, } from './process-fence.js';
+import { selectSetupHosts } from './prompts.js';
+import { planOpenCodeRegistration, registerOpenCode, registerPi, } from './register.js';
+export const AMBIGUOUS_OPENCODE_MESSAGE = 'Multiple OpenCode generations found. Choose --opencode=1|2|both before running noninteractive setup.';
+function flags(argv) {
+    const result = {
+        yes: false,
+        dryRun: false,
+        claustrum: false,
+        noClaustrum: false,
+        login: false,
+        opencode: undefined,
+    };
+    for (const arg of argv) {
+        if (arg === '--yes')
+            result.yes = true;
+        else if (arg === '--dry-run')
+            result.dryRun = true;
+        else if (arg === '--claustrum')
+            result.claustrum = true;
+        else if (arg === '--no-claustrum')
+            result.noClaustrum = true;
+        else if (arg === '--login')
+            result.login = true;
+        else if (/^--opencode=(1|2|both)$/.test(arg))
+            result.opencode = arg.slice('--opencode='.length);
+        else
+            throw new Error(`Unknown setup argument: ${arg}`);
+    }
+    if (result.claustrum && result.noClaustrum)
+        throw new Error('--claustrum and --no-claustrum cannot be used together.');
+    if (result.login && result.claustrum)
+        throw new Error('--login and --claustrum cannot be used together.');
+    return result;
+}
+function validatePlugin(plugin) {
+    for (const pkg of Object.values(plugin.packages)) {
+        if (!/^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/.test(pkg))
+            throw new Error('Setup requires npm package names.');
+    }
+    if (!/^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?(?:\+[a-zA-Z0-9.-]+)?$/.test(plugin.version))
+        throw new Error('Setup requires a concrete package version.');
+    for (const host of Object.values(plugin.vault.hosts)) {
+        if (!/^[a-z0-9][a-z0-9-]*$/.test(host.name))
+            throw new Error('Setup requires lowercase vault names containing only letters, digits and dashes.');
+    }
+}
+export async function runSetup(plugin, argv = [], io = {}) {
+    const options = flags(argv);
+    validatePlugin(plugin);
+    const terminal = io.terminal ?? processTerminal();
+    const detection = await detectHosts(plugin, io);
+    printLine(terminal, `${plugin.displayName} setup`);
+    for (const [label, host] of [
+        ['OpenCode', detection.opencode],
+        ['Pi', detection.pi],
+    ]) {
+        printLine(terminal, `${label}: ${host.installed ? `found (version ${host.version ?? 'unknown'})` : 'not found'} — ${host.directory}`);
+    }
+    printLine(terminal, `Claustrum: ${detection.claustrum.available ? 'available' : 'not available'}`);
+    // Pi is registered by running its CLI, so a leftover Pi folder without the
+    // CLI cannot be set up. Leave it out instead of failing the whole run, so it
+    // never blocks setting up OpenCode.
+    const piWithoutCli = detection.pi.installed && !detection.pi.executable;
+    if (piWithoutCli)
+        printLine(terminal, 'Pi: skipped, because its folder exists but pi is not on PATH. Install the Pi CLI and rerun setup to add it.');
+    const found = ['opencode', 'pi'].filter((host) => detection[host].installed && !(host === 'pi' && piWithoutCli));
+    // A dry run changes nothing, so without a terminal it plans the --yes path
+    // instead of refusing; scripts and CI can preview setup with --dry-run alone.
+    const assumeYes = options.yes || (options.dryRun && !isInteractive(terminal));
+    if (!assumeYes && !isInteractive(terminal))
+        throw new Error('Setup requires a TTY or --yes.');
+    const hosts = assumeYes
+        ? found
+        : ((await selectSetupHosts(terminal, found)) ?? []);
+    let generation = options.opencode ??
+        (detection.opencode.generation === 'ambiguous'
+            ? '1'
+            : detection.opencode.generation);
+    if (hosts.includes('opencode') &&
+        !options.opencode &&
+        detection.opencode.generation === 'ambiguous') {
+        if (assumeYes || !isInteractive(terminal))
+            throw new Error(AMBIGUOUS_OPENCODE_MESSAGE);
+        const choice = await select(terminal, [
+            { value: '1', label: 'OpenCode 1' },
+            { value: '2', label: 'OpenCode 2' },
+            { value: 'both', label: 'Both (one compatible registration)' },
+        ], { message: 'Which OpenCode generation should be registered?' });
+        if (choice === null)
+            return { hosts: [], dryRun: options.dryRun, mode: 'local', detection };
+        generation = choice;
+    }
+    if (!hosts.length) {
+        printLine(terminal, 'No hosts selected. Install OpenCode or Pi and rerun setup.');
+        return { hosts, dryRun: options.dryRun, mode: 'local', detection };
+    }
+    const { env, platform } = setupPaths(io);
+    const fence = io.fence ??
+        createProcessFence(io.runner ?? defaultCommandRunner, { platform });
+    const stopped = async () => {
+        try {
+            await assertHostsStopped(fence, env);
+        }
+        catch (error) {
+            if (error instanceof ProcessInspectionError)
+                printLine(terminal, error.refusalText);
+            throw error;
+        }
+    };
+    printLine(terminal, 'Checking that OpenCode and Pi are not running…');
+    if (options.dryRun) {
+        try {
+            const preview = fence.previewRunningHosts
+                ? await fence.previewRunningHosts(env)
+                : { hosts: await fence.listRunningHosts(env), uncheckedRuntimes: 0 };
+            const active = preview.hosts;
+            if (preview.uncheckedRuntimes > 0)
+                printLine(terminal, 'Node or Bun programs are running; a real run checks whether any of them is OpenCode or Pi.');
+            const names = new Set(new ProcessFenceViolationError(active).activeHosts.map((host) => host.command.toLowerCase() === 'pi' ? 'Pi' : 'OpenCode'));
+            for (const name of names)
+                printLine(terminal, `${name} is running; setup will ask you to quit it.`);
+        }
+        catch (error) {
+            printLine(terminal, 'Process inspection failed; real setup will require successful inspection and stopped OpenCode/Pi hosts.');
+            if (error instanceof ProcessInspectionError)
+                printLine(terminal, error.refusalText);
+        }
+    }
+    else
+        await stopped();
+    if (options.claustrum && !detection.claustrum.available)
+        throw new Error('Claustrum is not available. Start ck or use --no-claustrum for local sign-in.');
+    let useVault = Boolean(options.claustrum);
+    if (!useVault &&
+        !options.login &&
+        !options.noClaustrum &&
+        !assumeYes &&
+        detection.claustrum.available &&
+        isInteractive(terminal)) {
+        // Not `confirm`: it reads Escape and Ctrl-C as "No", and "No" here means
+        // a local sign-in. Cancelling must stop setup before anything changes.
+        const choice = await select(terminal, [
+            { label: 'No', value: false },
+            { label: 'Yes', value: true },
+        ], { message: 'Connect these hosts to the Claustrum vault?' });
+        if (choice === null) {
+            printLine(terminal, 'Setup cancelled. Nothing was changed.');
+            return { hosts: [], dryRun: options.dryRun, mode: 'local', detection };
+        }
+        useVault = choice === true;
+    }
+    const mode = useVault ? 'claustrum' : 'local';
+    // Validate every config before login or enrollment can change credential state.
+    const writes = hosts.includes('opencode')
+        ? planOpenCodeRegistration(plugin, generation, io)
+        : [];
+    if (options.dryRun) {
+        printLine(terminal, 'Dry run: no registrations, enrollment, sign-in or migration will be performed.');
+        for (const host of hosts) {
+            if (plugin.beforeSignIn)
+                printLine(terminal, `Would run beforeSignIn(${host}, ${mode}).`);
+            if (useVault) {
+                const paths = hostEnrollmentPaths(plugin.vault.hosts[host].paths);
+                printLine(terminal, `Would Connect ${host}: write ${paths.statePath} and ${paths.tokenPath}; wait for ck auth enroll approve.`);
+            }
+            else
+                printLine(terminal, `Would sign in locally for ${host}.`);
+            if (plugin.beforeRegister)
+                printLine(terminal, `Would run beforeRegister(${host}, ${mode}).`);
+        }
+        for (const write of writes)
+            printLine(terminal, `${write.changed ? 'Would write' : 'Unchanged'} ${write.path}:\n${write.content}`);
+        if (hosts.includes('pi'))
+            printLine(terminal, `Would run ${detection.pi.executable} install npm:${plugin.packages.pi}@${plugin.version}`);
+        for (const host of hosts)
+            printLine(terminal, `Would migrate ${host} using the plugin callback (provider-specific writes).`);
+    }
+    else {
+        const context = {
+            opencodeGeneration: generation,
+            mode,
+            hosts: Object.freeze([...hosts]),
+            piAgentDir: detection.pi.directory,
+        };
+        for (const host of hosts) {
+            await stopped();
+            await plugin.beforeSignIn?.(host, context);
+            await stopped();
+            if (useVault)
+                await connectSetupHost(plugin, host, io, terminal, stopped);
+            else
+                await plugin.signInLocal(host, context);
+            await stopped();
+            await plugin.beforeRegister?.(host, mode, context);
+            await stopped();
+            if (host === 'opencode')
+                await registerOpenCode(writes, stopped);
+            else
+                await registerPi(plugin, detection.pi.executable, io);
+            await stopped();
+            await plugin.migrate(host, context);
+        }
+    }
+    printLine(terminal, `${options.dryRun ? 'Planned' : 'Configured'} ${plugin.displayName} for ${hosts.join(', ')} (${mode}).`);
+    printLine(terminal, `Next: ${hosts.includes('opencode') ? 'start OpenCode' : 'start Pi'} and run ${plugin.slashCommand}.`);
+    return { hosts, dryRun: options.dryRun, mode, detection };
+}

package/dist/src/common-auth-embedded/setup/config-write.js

@@ -0,0 +1,60 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, rename, stat, unlink } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+/** Ordinary host config inherits Windows ACLs and preserves an existing POSIX mode. */
+export async function writeHostConfigAtomic(file, content, options = {}) {
+    const windows = (options.platform ?? process.platform) === 'win32';
+    const parent = dirname(file);
+    await mkdir(parent, { recursive: true });
+    let mode;
+    if (!windows) {
+        try {
+            mode = (await stat(file)).mode & 0o7777;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    const stage = join(parent, `.${basename(file)}.${(options.stageName ?? randomUUID)()}.tmp`);
+    let created = false;
+    try {
+        const handle = await open(stage, 'wx', mode ?? 0o666);
+        created = true;
+        try {
+            await handle.writeFile(content, 'utf8');
+            // An existing mode is deliberate; restore bits masked by the current umask.
+            if (mode !== undefined)
+                await handle.chmod(mode);
+        }
+        finally {
+            await handle.close();
+        }
+        const now = options.now ?? (() => performance.now());
+        const started = now();
+        for (let attempt = 0;; attempt++) {
+            await options.beforeRename?.();
+            try {
+                await (options.rename ?? rename)(stage, file);
+                created = false;
+                return;
+            }
+            catch (error) {
+                const code = error.code;
+                const remaining = 2000 - (now() - started);
+                if (!windows ||
+                    !['EPERM', 'EBUSY', 'EACCES'].includes(code ?? '') ||
+                    remaining <= 0 ||
+                    attempt >= 40)
+                    throw new Error(`Unable to replace host config ${file}. Close editors or other programs using the file, then rerun setup.`);
+                await (options.wait ?? delay)(Math.min(remaining, 25 * 2 ** Math.min(attempt, 2)));
+            }
+        }
+    }
+    finally {
+        // Never remove a colliding stage that this call did not create.
+        if (created)
+            await unlink(stage).catch(() => { });
+    }
+}

package/dist/src/common-auth-embedded/setup/detect.d.ts

@@ -0,0 +1,6 @@
+import type { SetupDetection, SetupFileSystem, SetupIO, SetupPlugin } from './types.js';
+export declare const defaultSetupFileSystem: SetupFileSystem;
+export declare function findExecutableOnPath(name: string, io?: SetupIO): string | null;
+export declare function openCodeDesktopMarkers(io?: SetupIO): string[];
+export declare function detectOpenCodeGeneration(io?: SetupIO): '1' | '2' | 'ambiguous';
+export declare function detectHosts(plugin: SetupPlugin, io?: SetupIO): Promise<SetupDetection>;