create-agent-rig 0.9.0 → 0.10.0

package/packages/cli/dist/integrations/spawn.js

@@ -0,0 +1,228 @@
+import { spawn } from 'node:child_process';
+import { realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { WINDOWS_JOB_SUPERVISOR } from './windows-job.js';
+// Only compiled adapters choose executable/argv. Repository declarations never
+// flow into these fields. The caller parses output; it must not log raw output.
+export async function runProviderProcess(options) {
+    const timeoutMs = options.timeoutMs ?? 60_000;
+    const maxOutputBytes = options.maxOutputBytes ?? 256 * 1024;
+    const failed = () => ({
+        status: 'failed',
+        stdout: '',
+        stderr: '',
+        exitCode: null,
+    });
+    if (!path.isAbsolute(options.executable) ||
+        !path.isAbsolute(options.repoDir) ||
+        !Number.isSafeInteger(timeoutMs) ||
+        timeoutMs < 1 ||
+        timeoutMs > 300_000 ||
+        !Number.isSafeInteger(maxOutputBytes) ||
+        maxOutputBytes < 1 ||
+        maxOutputBytes > 1024 * 1024)
+        return failed();
+    let cwd;
+    try {
+        cwd = await realpath(options.repoDir);
+        if (!(await stat(cwd)).isDirectory())
+            return failed();
+    }
+    catch {
+        return failed();
+    }
+    const env = { NO_COLOR: '1', UV_NO_PROGRESS: '1', PYTHONUTF8: '1' };
+    const allowed = new Set([
+        'PATH',
+        // uv resolves git through PATHEXT on Windows; without it the job
+        // supervisor leaves only `.CPL` and every git-sourced provider fails.
+        'PATHEXT',
+        'HOME',
+        'USERPROFILE',
+        'APPDATA',
+        'LOCALAPPDATA',
+        'TEMP',
+        'TMP',
+        'SYSTEMROOT',
+        'LANG',
+        'LC_ALL',
+        'SSL_CERT_FILE',
+        'SSL_CERT_DIR',
+        'XDG_CACHE_HOME',
+        'UV_CACHE_DIR',
+    ]);
+    for (const [key, value] of Object.entries(process.env)) {
+        if (allowed.has(key.toUpperCase()))
+            env[key] = value;
+    }
+    const isWindows = process.platform === 'win32';
+    let powershell;
+    if (isWindows) {
+        const systemRoot = process.env.SystemRoot ?? process.env.SYSTEMROOT;
+        if (systemRoot === undefined || !path.isAbsolute(systemRoot))
+            return failed();
+        powershell = path.join(systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+        // PowerShell 7 compiles this fixed C# source in-process. Prefer the standard
+        // installed runtime: Windows PowerShell's external CodeDom compiler stalls
+        // on the hosted image before provider creation. Do not install a runtime or
+        // search repository-controlled PATH entries for this supervisor.
+        const programFiles = process.env.ProgramFiles ?? process.env.PROGRAMFILES;
+        if (programFiles !== undefined && path.isAbsolute(programFiles)) {
+            const modern = path.join(programFiles, 'PowerShell', '7', 'pwsh.exe');
+            try {
+                const resolved = await realpath(modern);
+                const relative = path.relative(cwd, resolved);
+                if ((relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) &&
+                    (await stat(resolved)).isFile())
+                    powershell = resolved;
+            }
+            catch {
+                // The built-in Windows PowerShell remains the baseline on machines
+                // without PowerShell 7; the same operation deadline still applies.
+            }
+        }
+    }
+    return new Promise((resolve) => {
+        let child;
+        try {
+            if (isWindows)
+                env.RIG_WINDOWS_JOB_PAYLOAD = Buffer.from(JSON.stringify({ executable: options.executable, cwd, args: options.args })).toString('base64');
+            child = spawn(isWindows ? powershell : options.executable, isWindows
+                ? ['-NoProfile', '-NonInteractive', '-Command', WINDOWS_JOB_SUPERVISOR]
+                : options.args, {
+                cwd,
+                env,
+                shell: false,
+                windowsHide: true,
+                detached: !isWindows,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch {
+            resolve(failed());
+            return;
+        }
+        let stdout = Buffer.alloc(0);
+        let stderr = Buffer.alloc(0);
+        let settled = false;
+        let stopping = false;
+        let exited = false;
+        let closed = false;
+        let exitCode = null;
+        const text = (bytes) => {
+            let result = bytes.toString('utf8');
+            while (Buffer.byteLength(result) > maxOutputBytes)
+                result = result.slice(0, -1);
+            return result;
+        };
+        const finish = (status) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            child.unref();
+            resolve({
+                status,
+                stdout: text(stdout),
+                stderr: text(stderr),
+                exitCode: status === 'ok' || status === 'failed' ? exitCode : null,
+            });
+        };
+        const groupAlive = () => {
+            if (!child.pid)
+                return false;
+            try {
+                process.kill(-child.pid, 0);
+                return true;
+            }
+            catch (error) {
+                return error.code !== 'ESRCH';
+            }
+        };
+        const terminate = async (status) => {
+            if (stopping || settled)
+                return;
+            stopping = true;
+            const pid = child.pid;
+            if (!pid) {
+                finish('failed');
+                return;
+            }
+            let confirmed;
+            if (process.platform === 'win32') {
+                // The fixed supervisor owns a KILL_ON_JOB_CLOSE job before the provider
+                // is resumed. Terminating it closes that handle and kills every member.
+                try {
+                    child.kill();
+                    confirmed = true;
+                }
+                catch {
+                    confirmed = false;
+                }
+            }
+            else {
+                try {
+                    process.kill(-pid, 'SIGKILL');
+                }
+                catch (error) {
+                    if (error.code !== 'ESRCH') {
+                        finish('cleanup-unconfirmed');
+                        return;
+                    }
+                }
+                const deadline = Date.now() + 2000;
+                while (groupAlive() && Date.now() < deadline)
+                    await delay(20);
+                confirmed = !groupAlive();
+            }
+            if (confirmed && !closed) {
+                const deadline = Date.now() + 500;
+                while (!closed && Date.now() < deadline)
+                    await delay(10);
+            }
+            finish(confirmed && closed ? status : 'cleanup-unconfirmed');
+        };
+        const collect = (stream, chunk) => {
+            const old = stream === 'stdout' ? stdout : stderr;
+            const next = Buffer.concat([
+                old,
+                chunk.subarray(0, Math.max(0, maxOutputBytes - old.length)),
+            ]);
+            if (stream === 'stdout')
+                stdout = next;
+            else
+                stderr = next;
+            if (old.length + chunk.length > maxOutputBytes)
+                void terminate('output-limit');
+        };
+        child.stdout?.on('data', (chunk) => collect('stdout', chunk));
+        child.stderr?.on('data', (chunk) => collect('stderr', chunk));
+        child.on('error', () => {
+            if (!stopping)
+                finish('failed');
+        });
+        child.on('exit', (code) => {
+            exited = true;
+            exitCode = code;
+        });
+        child.on('close', (code) => {
+            closed = true;
+            exitCode = code;
+            if (stopping)
+                return;
+            if (process.platform === 'win32' && code === 125) {
+                finish('cleanup-unconfirmed');
+                return;
+            }
+            if (process.platform !== 'win32' && groupAlive()) {
+                void terminate('cleanup-unconfirmed');
+            }
+            else
+                finish(code === 0 ? 'ok' : 'failed');
+        });
+        const timer = setTimeout(() => void terminate(exited ? 'cleanup-unconfirmed' : 'timeout'), timeoutMs);
+    });
+}

package/packages/cli/dist/integrations/spec-kit.js

@@ -0,0 +1,280 @@
+import { constants } from 'node:fs';
+import { access, realpath, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { resolveReadableInside } from '../lib/safe-path.js';
+import { isPlainObject } from '../lib/safe-text.js';
+import { runProviderProcess } from './spawn.js';
+export const SPEC_KIT_VERSION = '1.0.8';
+const SOURCE = `git+https://github.com/github/spec-kit@v${SPEC_KIT_VERSION}`;
+const PREFIX = ['--from', SOURCE, 'specify'];
+// v1.0.8's status vocabulary. Unknown upstream strings never reach diagnostics.
+const STATUS_CODES = new Set([
+    'default-integration-missing',
+    'default-integration-not-installed',
+    'installed-integrations-invalid',
+    'integration-key-invalid',
+    'integration-state-missing',
+    'integration-state-unreadable',
+    'managed-file-collision',
+    'managed-files-missing',
+    'managed-files-modified',
+    'manifest-missing',
+    'manifest-paths-invalid',
+    'manifest-unreadable',
+    'no-installed-integrations',
+    'project-root-unresolved',
+    'unknown-integration',
+    'unsafe-multi-install',
+]);
+async function locate(name, repoDir, env = process.env) {
+    const root = await realpath(repoDir);
+    const inside = (file) => {
+        const relative = path.relative(root, file);
+        return (relative === '' ||
+            (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`)));
+    };
+    const filename = process.platform === 'win32' ? `${name}.exe` : name;
+    for (const directory of (env.PATH ?? env.Path ?? '').split(path.delimiter)) {
+        if (!path.isAbsolute(directory))
+            continue;
+        try {
+            const candidate = path.join(directory, filename);
+            const file = await realpath(candidate);
+            if (inside(candidate) || inside(file))
+                continue;
+            if (!(await stat(file)).isFile())
+                continue;
+            await access(file, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+            return candidate;
+        }
+        catch {
+            /* Try the next machine PATH entry, never the repository. */
+        }
+    }
+    return undefined;
+}
+/** Only the official read-only status command; network and Python downloads disabled. */
+export async function inspectSpecKit(options) {
+    const uvx = await locate('uvx', options.repoDir, options.env);
+    if (!uvx)
+        return {
+            status: 'warn',
+            reason: 'upstream-status-unavailable',
+            launcher: 'missing',
+            runtime: 'unverified',
+        };
+    const result = await (options.runner ?? runProviderProcess)({
+        executable: uvx,
+        args: [
+            '--offline',
+            '--no-config',
+            '--no-python-downloads',
+            ...PREFIX,
+            'integration',
+            'status',
+            '--json',
+        ],
+        repoDir: options.repoDir,
+        timeoutMs: 30_000,
+        maxOutputBytes: 256 * 1024,
+    });
+    if (result.status === 'cleanup-unconfirmed')
+        return {
+            status: 'fail',
+            reason: 'upstream-cleanup-unconfirmed',
+            launcher: 'observed',
+            runtime: 'unverified',
+        };
+    const observed = observe(result);
+    if (observed === undefined)
+        return {
+            status: result.status === 'failed' ? 'warn' : 'fail',
+            reason: 'upstream-status-unavailable',
+            launcher: 'observed',
+            runtime: 'unverified',
+        };
+    const complete = options.harnesses.every((harness) => observed.installedIntegrations.includes(harness === 'claude-code' ? 'claude' : 'codex'));
+    const status = observed.status === 'error' || result.exitCode !== 0
+        ? 'fail'
+        : observed.status === 'warning' || !complete
+            ? 'warn'
+            : 'pass';
+    return {
+        status,
+        reason: !complete ? 'upstream-harness-status-incomplete' : `upstream-status-${observed.status}`,
+        launcher: 'observed',
+        runtime: 'verified',
+        observed,
+    };
+}
+function observe(result) {
+    if (result.status !== 'ok' && result.status !== 'failed')
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(result.stdout);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isPlainObject(value) ||
+        !['ok', 'warning', 'error'].includes(String(value.status)) ||
+        !Array.isArray(value.installed_integrations) ||
+        value.installed_integrations.length > 64 ||
+        !value.installed_integrations.every((id) => typeof id === 'string' && /^[a-z0-9][a-z0-9-]{0,63}$/.test(id)))
+        return undefined;
+    // Diagnosis keeps finite codes, not upstream free text that could contain
+    // credentials. Rig never persists this observed runtime state as intent.
+    const findings = Array.isArray(value.findings)
+        ? value.findings.flatMap((finding) => isPlainObject(finding) &&
+            typeof finding.code === 'string' &&
+            STATUS_CODES.has(finding.code) &&
+            ['info', 'warning', 'error'].includes(String(finding.severity))
+            ? [{ code: finding.code, severity: String(finding.severity) }]
+            : [])
+        : [];
+    if (!Array.isArray(value.findings) || findings.length !== value.findings.length)
+        return undefined;
+    return {
+        status: value.status,
+        installedIntegrations: value.installed_integrations.filter((id) => id === 'claude' || id === 'codex'),
+        findings,
+    };
+}
+export async function runSpecKitLifecycle(options) {
+    const plan = [
+        `Spec Kit ${SPEC_KIT_VERSION}; requires local uv, uvx and git, invoked from the repository root. Downloads the official pinned source and dependencies into the uv cache; no global tool installation.`,
+        `uvx --from ${SOURCE} specify`,
+        'Configure integration files without checking whether Claude Code or Codex is installed; this does not verify harness runtime or trust.',
+    ];
+    const refuse = (reason, observed) => ({
+        ok: false,
+        reason,
+        plan,
+        ...(observed === undefined ? {} : { observed }),
+    });
+    if (!options.harnesses.length ||
+        new Set(options.harnesses).size !== options.harnesses.length ||
+        options.harnesses.some((harness) => harness !== 'claude-code' && harness !== 'codex'))
+        return refuse('invalid-harness-selection');
+    const harnesses = options.harnesses.map((harness) => harness === 'claude-code' ? 'claude' : 'codex');
+    const project = await resolveReadableInside(options.repoDir, '.specify', 'directory');
+    if (project.status !== 'ok' && project.status !== 'absent')
+        return refuse('spec-kit-project-path-unsafe');
+    const initialized = project.status === 'ok';
+    if (options.operation === 'add' && !initialized) {
+        plan.push(`init --here --force --non-interactive --ignore-agent-tools --integration ${harnesses[0]}`, ...harnesses.slice(1).map((harness) => `integration install ${harness}`));
+    }
+    else if (options.operation === 'add') {
+        plan.push('integration status --json', ...harnesses.map((harness) => `integration install ${harness} (only if absent from status)`));
+    }
+    else {
+        plan.push(...harnesses.map((harness) => `integration ${options.operation === 'apply' ? 'upgrade' : 'uninstall'} ${harness}`));
+    }
+    plan.push('integration status --json');
+    if (!options.consent)
+        return refuse('consent-required');
+    if (initialized && !options.managed && !options.adopt)
+        return refuse('explicit-adoption-required');
+    if (options.operation !== 'add' && (!initialized || !options.managed))
+        return refuse('managed-spec-kit-project-required');
+    const [uv, uvx, git] = await Promise.all([
+        locate('uv', options.repoDir),
+        locate('uvx', options.repoDir),
+        locate('git', options.repoDir),
+    ]);
+    if (!uv || !uvx || !git)
+        return refuse('uv-uvx-and-git-required');
+    const runner = options.runner ?? runProviderProcess;
+    const invoke = (executable, args) => runner({
+        executable,
+        args,
+        repoDir: options.repoDir,
+        timeoutMs: 120_000,
+        maxOutputBytes: 256 * 1024,
+    });
+    const upstream = (args) => invoke(uvx, [...PREFIX, ...args]);
+    const succeeded = (result) => result.status === 'ok' && result.exitCode === 0;
+    const root = await invoke(git, ['-c', 'core.fsmonitor=false', 'rev-parse', '--show-toplevel']);
+    if (!succeeded(root))
+        return refuse('repository-root-required');
+    try {
+        if (path.relative(await realpath(options.repoDir), await realpath(root.stdout.trim())) !== '')
+            return refuse('repository-root-required');
+    }
+    catch {
+        return refuse('repository-root-required');
+    }
+    if (!initialized || !options.managed) {
+        const dirty = await invoke(git, [
+            '-c',
+            'core.fsmonitor=false',
+            '--no-optional-locks',
+            'status',
+            '--porcelain=v1',
+            '--untracked-files=all',
+        ]);
+        if (!succeeded(dirty))
+            return refuse('git-status-unavailable');
+        if (dirty.stdout.trim())
+            return refuse('dirty-initialization-or-adoption-refused');
+    }
+    const commands = [];
+    if (options.operation === 'add' && !initialized) {
+        commands.push([
+            'init',
+            '--here',
+            '--force',
+            '--non-interactive',
+            '--ignore-agent-tools',
+            '--integration',
+            harnesses[0],
+        ], ...harnesses.slice(1).map((harness) => ['integration', 'install', harness]));
+    }
+    else if (options.operation === 'add') {
+        const status = await upstream(['integration', 'status', '--json']);
+        const current = observe(status);
+        if (!succeeded(status) || current?.status !== 'ok')
+            return refuse('upstream-status-not-ready', current);
+        commands.push(...harnesses
+            .filter((harness) => !current.installedIntegrations.includes(harness))
+            .map((harness) => ['integration', 'install', harness]));
+    }
+    else {
+        commands.push(...harnesses.map((harness) => [
+            'integration',
+            options.operation === 'apply' ? 'upgrade' : 'uninstall',
+            harness,
+        ]));
+    }
+    let partial = false;
+    for (const command of commands) {
+        const result = await upstream(command);
+        if (result.status === 'cleanup-unconfirmed')
+            return refuse('upstream-cleanup-unconfirmed');
+        if (!succeeded(result)) {
+            partial = true;
+            break;
+        }
+    }
+    const status = await upstream(['integration', 'status', '--json']);
+    const observed = observe(status);
+    // v1.0.8 removes integration.json after the last successful uninstall.
+    // Its authoritative status then exits 1 with this exact empty-state finding.
+    if (options.operation === 'remove' &&
+        !partial &&
+        status.status === 'failed' &&
+        status.exitCode === 1 &&
+        observed?.status === 'error' &&
+        observed.installedIntegrations.length === 0 &&
+        observed.findings.length === 1 &&
+        observed.findings[0]?.code === 'integration-state-missing' &&
+        observed.findings[0]?.severity === 'error')
+        return { ok: true, observed, plan };
+    if (partial || !succeeded(status) || observed?.status !== 'ok')
+        return refuse('upstream-incomplete-use-adopt-and-status', observed);
+    const complete = harnesses.every((harness) => observed.installedIntegrations.includes(harness) === (options.operation !== 'remove'));
+    return complete
+        ? { ok: true, observed, plan }
+        : refuse('upstream-harness-status-incomplete', observed);
+}