@cortexkit/opencode-antigravity-auth 3.0.5 → 3.0.6

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

@@ -0,0 +1,11 @@
+import type { OpenCodeGeneration, SetupIO, SetupPlugin } from './types.js';
+export interface PlannedWrite {
+    path: string;
+    content: string;
+    changed: boolean;
+}
+/** Edit only array entries so unrelated JSONC text, including comments, survives. */
+export declare function updatePluginConfig(text: string, key: 'plugin' | 'plugins', pkg: string, version: string): string;
+export declare function planOpenCodeRegistration(plugin: SetupPlugin, generation: OpenCodeGeneration, io?: SetupIO): PlannedWrite[];
+export declare function registerOpenCode(writes: readonly PlannedWrite[], beforeWrite?: () => Promise<void>): Promise<void>;
+export declare function registerPi(plugin: SetupPlugin, executable: string, io?: SetupIO): Promise<void>;

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

@@ -0,0 +1,130 @@
+import { applyEdits, createScanner, findNodeAtLocation, modify, parse, parseTree, } from 'jsonc-parser';
+import { defaultCommandRunner, runResolvedCommand } from './command-runner.js';
+import { writeHostConfigAtomic } from './config-write.js';
+import { defaultSetupFileSystem } from './detect.js';
+import { setupPaths } from './paths.js';
+function packageOf(value) {
+    const entry = typeof value === 'string'
+        ? value
+        : Array.isArray(value)
+            ? value[0]
+            : value && typeof value === 'object' && 'package' in value
+                ? value.package
+                : null;
+    if (typeof entry !== 'string')
+        return null;
+    const at = entry.indexOf('@', entry.startsWith('@') ? 1 : 0);
+    return at < 0 ? entry : entry.slice(0, at);
+}
+function removeArrayEntry(text, key, index) {
+    const tree = parseTree(text);
+    const array = tree && findNodeAtLocation(tree, [key]);
+    const nodes = array?.children ?? [];
+    const node = nodes[index];
+    if (!node || !array)
+        throw new Error('Invalid plugin array edit.');
+    const edits = [{ offset: node.offset, length: node.length, content: '' }];
+    const removeComma = (start, end) => {
+        const scanner = createScanner(text.slice(start, end), true);
+        scanner.scan();
+        if (text[start + scanner.getTokenOffset()] === ',')
+            edits.push({
+                offset: start + scanner.getTokenOffset(),
+                length: 1,
+                content: '',
+            });
+    };
+    // Delete punctuation separately so comments beside other entries are not removed.
+    if (index === nodes.length - 1) {
+        const previous = nodes[index - 1];
+        if (previous)
+            removeComma(previous.offset + previous.length, node.offset);
+        removeComma(node.offset + node.length, array.offset + array.length - 1);
+    }
+    else
+        removeComma(node.offset + node.length, nodes[index + 1]?.offset ?? node.offset + node.length);
+    return applyEdits(text, edits);
+}
+/** Edit only array entries so unrelated JSONC text, including comments, survives. */
+export function updatePluginConfig(text, key, pkg, version) {
+    const errors = [];
+    const value = parse(text, errors, { allowTrailingComma: true });
+    if (errors.length ||
+        !value ||
+        typeof value !== 'object' ||
+        Array.isArray(value))
+        throw new Error('Invalid OpenCode config; refusing to overwrite it.');
+    const options = {
+        formattingOptions: {
+            insertSpaces: !/^\t+/m.test(text),
+            tabSize: /^([ ]+)"/m.exec(text)?.[1]?.length ?? 2,
+            eol: text.includes('\r\n') ? '\r\n' : '\n',
+        },
+    };
+    let output = text;
+    const array = value[key];
+    if (array !== undefined && !Array.isArray(array))
+        throw new Error(`OpenCode ${key} must be an array.`);
+    const entries = Array.isArray(array) ? [...array] : [];
+    const matches = entries.flatMap((entry, index) => packageOf(entry) === pkg ? [index] : []);
+    const entry = `${pkg}@${version}`;
+    if (!matches.length) {
+        output = applyEdits(output, modify(output, array === undefined ? [key] : [key, entries.length], array === undefined ? [entry] : entry, options));
+    }
+    else {
+        const first = matches[0];
+        const previous = entries[first];
+        // Preserve options in OpenCode's [package, options] and { package, options } entries.
+        const replacement = Array.isArray(previous)
+            ? [entry, ...previous.slice(1)]
+            : previous && typeof previous === 'object'
+                ? { ...previous, package: entry }
+                : entry;
+        if (JSON.stringify(previous) !== JSON.stringify(replacement))
+            output = applyEdits(output, modify(output, [key, first], replacement, options));
+        for (const index of matches.slice(1).reverse())
+            output = removeArrayEntry(output, key, index);
+    }
+    const other = key === 'plugin' ? 'plugins' : 'plugin';
+    if (Array.isArray(value[other])) {
+        const otherEntries = value[other];
+        for (let index = otherEntries.length - 1; index >= 0; index--) {
+            if (packageOf(otherEntries[index]) === pkg)
+                output = removeArrayEntry(output, other, index);
+        }
+    }
+    return output;
+}
+export function planOpenCodeRegistration(plugin, generation, io = {}) {
+    const fs = io.fs ?? defaultSetupFileSystem;
+    const { path, opencode } = setupPaths(io);
+    const key = generation === '2' ? 'plugins' : 'plugin';
+    const names = generation === '2' ? ['opencode'] : ['opencode', 'tui'];
+    return names.map((name) => {
+        const jsonc = path.join(opencode, `${name}.jsonc`);
+        const json = path.join(opencode, `${name}.json`);
+        const file = fs.exists(jsonc) ? jsonc : fs.exists(json) ? json : jsonc;
+        const exists = fs.exists(file);
+        const before = exists
+            ? fs.readText(file)
+            : `${JSON.stringify({ $schema: `https://opencode.ai/${name === 'tui' ? 'tui' : 'config'}.json` }, null, 2)}\n`;
+        const content = updatePluginConfig(before, key, plugin.packages.opencode, plugin.version);
+        return { path: file, content, changed: !exists || content !== before };
+    });
+}
+export async function registerOpenCode(writes, beforeWrite) {
+    for (const write of writes) {
+        if (!write.changed)
+            continue;
+        await beforeWrite?.();
+        await writeHostConfigAtomic(write.path, write.content, {
+            beforeRename: beforeWrite,
+        });
+    }
+}
+export async function registerPi(plugin, executable, io = {}) {
+    const { platform, env } = setupPaths(io);
+    const result = await runResolvedCommand(io.runner ?? defaultCommandRunner, platform, executable, ['install', `npm:${plugin.packages.pi}@${plugin.version}`], env);
+    if (result.exitCode !== 0)
+        throw new Error('Pi install failed; run pi install after checking your npm connection.');
+}

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

@@ -0,0 +1,136 @@
+import type { MenuTerminal } from '../auth-menu/terminal.js';
+import type { ClaustrumEnrollmentConnection, hostEnrollmentPaths } from '../claustrum/index.js';
+export type SetupHost = 'opencode' | 'pi';
+export type OpenCodeGeneration = '1' | '2' | 'both';
+export type SetupEnvironment = Record<string, string | undefined>;
+/**
+ * What setup decided before calling a plugin callback. The OpenCode generation
+ * is the one being registered, after `--opencode` or the interactive choice, so
+ * a plugin can sign in the way that generation expects (OpenCode 2 does not
+ * read OpenCode 1's login file).
+ */
+export interface SetupCallbackContext {
+    opencodeGeneration: OpenCodeGeneration;
+    mode: 'local' | 'claustrum';
+    /**
+     * Every host this run sets up, in order, so the first `beforeSignIn` can
+     * check conditions across all of them (for example that their storage paths
+     * do not overlap) before any host is changed.
+     */
+    hosts: readonly SetupHost[];
+    /**
+     * Pi's agent folder, resolved the way Pi itself does (`PI_CODING_AGENT_DIR`,
+     * with `~` expanded, else `~/.pi/agent`). Pi's own `auth.json` lives here;
+     * use it rather than a plugin path setting, which can point elsewhere.
+     */
+    piAgentDir: string;
+}
+/** Provider login, credential migration and vault activation stay in plugin callbacks. */
+export interface SetupPlugin {
+    packages: {
+        opencode: string;
+        pi: string;
+    };
+    version: string;
+    displayName: string;
+    slashCommand: string;
+    vault: {
+        connectionFile: string;
+        hosts: Record<SetupHost, {
+            name: string;
+            paths: Parameters<typeof hostEnrollmentPaths>[0];
+        }>;
+    };
+    /**
+     * Runs for each host on a real run after the host, mode and generation are
+     * chosen and before the vault ceremony or `signInLocal`, while nothing has
+     * changed yet. Rejecting stops setup for that host, so a plugin can ask for
+     * consent or check preconditions before any credential or authority change.
+     */
+    beforeSignIn?(host: SetupHost, context: SetupCallbackContext): Promise<void>;
+    signInLocal(host: SetupHost, context: SetupCallbackContext): Promise<void>;
+    migrate(host: SetupHost, context: SetupCallbackContext): Promise<void>;
+    /** Reject mixed local/vault credentials and activate provider-specific vault access before registration. */
+    beforeRegister?(host: SetupHost, mode: 'local' | 'claustrum', context: SetupCallbackContext): Promise<void>;
+}
+export interface CommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    signal?: NodeJS.Signals | null;
+    timedOut?: boolean;
+    durationMs?: number;
+}
+export interface CommandRunner {
+    run(file: string, args: readonly string[], options?: {
+        env?: SetupEnvironment;
+        timeoutMs?: number;
+        windowsVerbatimArguments?: boolean;
+    }): Promise<CommandResult>;
+}
+export interface SetupFileSystem {
+    exists(path: string): boolean;
+    isDirectory(path: string): boolean;
+    isFile(path: string): boolean;
+    isExecutable(path: string): boolean;
+    readText(path: string): string;
+    realpath(path: string): string;
+}
+export interface ProcessFence {
+    listRunningHosts(env?: SetupEnvironment): Promise<Array<{
+        pid: number;
+        command: string;
+    }>>;
+    /**
+     * For a dry run, which must change nothing: the hosts found without starting
+     * any program that writes files. On Windows that skips the PowerShell query
+     * for Node and Bun command lines (PowerShell writes a startup cache into the
+     * user's profile), so Node or Bun processes are only counted. A fence without
+     * it is previewed with `listRunningHosts`.
+     */
+    previewRunningHosts?(env?: SetupEnvironment): Promise<{
+        hosts: Array<{
+            pid: number;
+            command: string;
+        }>;
+        uncheckedRuntimes: number;
+    }>;
+}
+/** Defaults use the process terminal and environment; overrides are test seams. */
+export interface SetupIO {
+    terminal?: MenuTerminal;
+    env?: SetupEnvironment;
+    platform?: string;
+    home?: string;
+    cwd?: string;
+    fs?: SetupFileSystem;
+    runner?: CommandRunner;
+    fence?: ProcessFence;
+    connect?: (options: {
+        connectionFile: string;
+        handshakeTimeoutMs: number;
+    }) => Promise<ClaustrumEnrollmentConnection>;
+    wait?: (ms: number) => Promise<void>;
+}
+export interface HostDetection {
+    installed: boolean;
+    executable: string | null;
+    version: string | null;
+    directory: string;
+}
+export interface SetupDetection {
+    opencode: HostDetection & {
+        generation: '1' | '2' | 'ambiguous';
+    };
+    pi: HostDetection;
+    claustrum: {
+        available: boolean;
+        executable: string | null;
+    };
+}
+export interface SetupResult {
+    hosts: SetupHost[];
+    dryRun: boolean;
+    mode: 'local' | 'claustrum';
+    detection: SetupDetection;
+}