workos 0.19.0 → 0.20.2

package/dist/lib/installer-core.js

@@ -1,1134 +0,0 @@
-import { setup, assign, fromPromise } from 'xstate';
-import { getManualPrInstructions } from './post-install.js';
-import { hasGhCli } from '../utils/git-utils.js';
-import { formatWorkOSCommand } from '../utils/command-invocation.js';
-export const installerMachine = setup({
-    types: {
-        context: {},
-        input: {},
-        events: {},
-    },
-    actions: {
-        emitStateEnter: ({ context }, params) => {
-            context.emitter.emit('state:enter', { state: params.state });
-        },
-        emitStateExit: ({ context }, params) => {
-            context.emitter.emit('state:exit', { state: params.state });
-        },
-        emitAuthChecking: ({ context }) => {
-            context.emitter.emit('auth:checking', {});
-        },
-        emitAuthRequired: ({ context }) => {
-            context.emitter.emit('auth:required', {});
-        },
-        emitAuthSuccess: ({ context }) => {
-            context.emitter.emit('auth:success', {});
-        },
-        emitAuthFailure: ({ context }) => {
-            const message = context.error?.message ?? 'Authentication failed';
-            context.emitter.emit('auth:failure', { message });
-        },
-        emitDetectionStart: ({ context }) => {
-            context.emitter.emit('detection:start', {});
-        },
-        emitDetectionComplete: ({ context }) => {
-            if (context.integration) {
-                context.emitter.emit('detection:complete', { integration: context.integration });
-            }
-            else {
-                context.emitter.emit('detection:none', {});
-            }
-        },
-        emitGitChecking: ({ context }) => {
-            context.emitter.emit('git:checking', {});
-        },
-        emitGitClean: ({ context }) => {
-            context.emitter.emit('git:clean', {});
-        },
-        emitGitDirty: ({ context }) => {
-            context.emitter.emit('git:dirty', { files: context.gitDirtyFiles });
-        },
-        emitGitConfirmed: ({ context }) => {
-            context.emitter.emit('git:dirty:confirmed', {});
-        },
-        emitGitCancelled: ({ context }) => {
-            context.emitter.emit('git:dirty:cancelled', {});
-        },
-        emitScaffoldChecking: ({ context }) => {
-            context.emitter.emit('scaffold:checking', {});
-        },
-        emitScaffoldPrompt: ({ context }) => {
-            context.emitter.emit('scaffold:prompt', { packageManager: context.packageManager ?? 'npm' });
-        },
-        emitScaffoldStart: ({ context }) => {
-            context.emitter.emit('scaffold:start', { packageManager: context.packageManager ?? 'npm' });
-        },
-        emitScaffoldComplete: ({ context }) => {
-            context.emitter.emit('scaffold:complete', {});
-        },
-        emitScaffoldFailed: ({ context }) => {
-            const message = context.error?.message ?? 'Scaffold failed';
-            context.emitter.emit('scaffold:failed', { error: message });
-        },
-        emitScaffoldSkipped: ({ context }) => {
-            context.emitter.emit('scaffold:skipped', {});
-        },
-        assignWorkspaceResult: assign({
-            scaffoldable: ({ event }) => event.output?.scaffoldable ?? false,
-            packageManager: ({ event }) => event.output?.packageManager ?? 'npm',
-            autoScaffold: ({ event }) => event.output?.autoScaffold ?? false,
-        }),
-        assignScaffolded: assign({
-            scaffolded: () => true,
-        }),
-        emitBranchChecking: ({ context }) => {
-            context.emitter.emit('branch:checking', {});
-        },
-        emitBranchProtected: ({ context }) => {
-            if (context.currentBranch) {
-                context.emitter.emit('branch:protected', { branch: context.currentBranch });
-                context.emitter.emit('branch:prompt', { branch: context.currentBranch });
-            }
-        },
-        emitBranchCreated: ({ context }, params) => {
-            context.emitter.emit('branch:created', { branch: params.branch });
-        },
-        emitBranchCreateFailed: ({ context }) => {
-            const message = context.error?.message ?? 'Failed to create branch';
-            context.emitter.emit('branch:create:failed', { error: message });
-        },
-        assignBranchResult: assign({
-            currentBranch: ({ event }) => {
-                const doneEvent = event;
-                return doneEvent.output?.branch ?? undefined;
-            },
-            isProtectedBranch: ({ event }) => {
-                const doneEvent = event;
-                return doneEvent.output?.isProtected ?? false;
-            },
-        }),
-        emitCredentialsGathering: ({ context }) => {
-            const requiresApiKey = ['nextjs', 'tanstack-start', 'react-router'].includes(context.integration ?? '');
-            context.emitter.emit('credentials:gathering', { requiresApiKey });
-            context.emitter.emit('credentials:request', { requiresApiKey });
-        },
-        emitCredentialsFound: ({ context }) => {
-            context.emitter.emit('credentials:found', {});
-        },
-        emitEnvDetected: ({ context }) => {
-            context.emitter.emit('credentials:env:detected', { files: context.envFilesDetected ?? [] });
-        },
-        emitEnvScanPrompt: ({ context }) => {
-            context.emitter.emit('credentials:env:prompt', { files: context.envFilesDetected ?? [] });
-        },
-        emitEnvScanning: ({ context }) => {
-            context.emitter.emit('credentials:env:scanning', {});
-        },
-        emitEnvCredentialsFound: ({ context }) => {
-            context.emitter.emit('credentials:env:found', { sourcePath: context.envCredentialPath ?? '.env' });
-        },
-        emitEnvNotFound: ({ context }) => {
-            context.emitter.emit('credentials:env:notfound', {});
-        },
-        emitDeviceAuthStart: () => {
-            // Emitted by actor when it has verification URL
-        },
-        emitDeviceAuthSuccess: ({ context }) => {
-            context.emitter.emit('device:success', { email: undefined });
-        },
-        emitDeviceAuthError: ({ context }) => {
-            const message = context.error?.message ?? 'Device authorization failed';
-            context.emitter.emit('device:error', { message });
-        },
-        emitDeviceTimeout: ({ context }) => {
-            context.emitter.emit('device:timeout', {});
-        },
-        emitStagingFetching: ({ context }) => {
-            context.emitter.emit('staging:fetching', {});
-        },
-        emitStagingSuccess: ({ context }) => {
-            context.emitter.emit('staging:success', { source: context.deviceAuth ? 'device' : 'stored' });
-        },
-        emitStagingError: ({ context }) => {
-            const message = context.error?.message ?? 'Failed to fetch staging credentials';
-            context.emitter.emit('staging:error', { message });
-        },
-        emitConfigStart: ({ context }) => {
-            context.emitter.emit('config:start', {});
-        },
-        emitConfigComplete: ({ context }) => {
-            context.emitter.emit('config:complete', {});
-        },
-        emitAgentStart: ({ context }) => {
-            context.emitter.emit('agent:start', {});
-        },
-        emitAgentSuccess: ({ context }, params) => {
-            context.emitter.emit('agent:success', { summary: params.summary });
-            context.emitter.emit('complete', { success: true, summary: params.summary });
-        },
-        emitAgentFailure: ({ context }) => {
-            const message = context.error?.message ?? 'Agent execution failed';
-            const stack = context.error?.stack;
-            context.emitter.emit('agent:failure', { message, stack });
-            context.emitter.emit('complete', { success: false });
-        },
-        assignDetectionResult: assign({
-            integration: ({ event }) => {
-                const doneEvent = event;
-                return doneEvent.output?.integration;
-            },
-        }),
-        assignGitResult: assign({
-            gitIsClean: ({ event }) => {
-                const doneEvent = event;
-                return doneEvent.output?.isClean ?? true;
-            },
-            gitDirtyFiles: ({ event }) => {
-                const doneEvent = event;
-                return doneEvent.output?.files ?? [];
-            },
-        }),
-        assignCredentials: assign({
-            credentials: ({ event }) => {
-                if (event.type === 'CREDENTIALS_SUBMITTED') {
-                    return { apiKey: event.apiKey, clientId: event.clientId };
-                }
-                return undefined;
-            },
-        }),
-        assignError: assign({
-            error: ({ event }) => {
-                if ('error' in event && event.error instanceof Error) {
-                    return event.error;
-                }
-                if ('error' in event && typeof event.error === 'object' && event.error !== null) {
-                    return new Error(String(event.error.message ?? event.error));
-                }
-                return new Error('Unknown error');
-            },
-        }),
-        emitCancelled: ({ context }) => {
-            context.emitter.emit('complete', { success: false, summary: 'Installer cancelled by user' });
-        },
-        emitError: ({ context }) => {
-            const message = context.error?.message ?? 'An unexpected error occurred';
-            context.emitter.emit('error', { message, stack: context.error?.stack });
-            context.emitter.emit('complete', { success: false });
-        },
-        // Post-install actions
-        assignChangedFiles: assign({
-            changedFiles: ({ event }) => {
-                const doneEvent = event;
-                return doneEvent.output?.files ?? [];
-            },
-        }),
-        emitChangesDetected: ({ context }) => {
-            context.emitter.emit('postinstall:changes', { files: context.changedFiles ?? [] });
-        },
-        emitNoChanges: ({ context }) => {
-            context.emitter.emit('postinstall:nochanges', {});
-        },
-        emitCommitPrompt: ({ context }) => {
-            context.emitter.emit('postinstall:commit:prompt', {});
-        },
-        emitGeneratingCommitMessage: ({ context }) => {
-            context.emitter.emit('postinstall:commit:generating', {});
-        },
-        assignCommitMessage: assign({
-            commitMessage: ({ event }) => {
-                const doneEvent = event;
-                return doneEvent.output;
-            },
-        }),
-        emitCommitting: ({ context }) => {
-            context.emitter.emit('postinstall:commit:committing', { message: context.commitMessage ?? '' });
-        },
-        emitCommitSuccess: ({ context }) => {
-            context.emitter.emit('postinstall:commit:success', { message: context.commitMessage ?? '' });
-        },
-        emitCommitFailed: ({ context }) => {
-            const message = context.error?.message ?? 'Commit failed';
-            context.emitter.emit('postinstall:commit:failed', { error: message });
-        },
-        emitPrPrompt: ({ context }) => {
-            context.emitter.emit('postinstall:pr:prompt', {});
-        },
-        emitGeneratingPrDescription: ({ context }) => {
-            context.emitter.emit('postinstall:pr:generating', {});
-        },
-        assignPrDescription: assign({
-            prDescription: ({ event }) => {
-                const doneEvent = event;
-                return doneEvent.output;
-            },
-        }),
-        emitPushing: ({ context }) => {
-            context.emitter.emit('postinstall:pr:pushing', {});
-        },
-        emitPushFailed: ({ context }) => {
-            const message = context.error?.message ?? 'Push failed';
-            context.emitter.emit('postinstall:push:failed', { error: message });
-        },
-        emitCreatingPr: ({ context }) => {
-            context.emitter.emit('postinstall:pr:creating', {});
-        },
-        assignPrUrl: assign({
-            prUrl: ({ event }) => {
-                const doneEvent = event;
-                return doneEvent.output;
-            },
-        }),
-        emitPrCreated: ({ context }) => {
-            context.emitter.emit('postinstall:pr:success', { url: context.prUrl ?? '' });
-        },
-        emitPrFailed: ({ context }) => {
-            const message = context.error?.message ?? 'PR creation failed';
-            context.emitter.emit('postinstall:pr:failed', { error: message });
-        },
-        emitManualInstructions: ({ context }) => {
-            const branch = context.currentBranch ?? 'HEAD';
-            const instructions = getManualPrInstructions(branch);
-            context.emitter.emit('postinstall:manual', { instructions });
-        },
-        emitComplete: ({ context }) => {
-            const summary = context.agentSummary ?? 'WorkOS AuthKit installed successfully!';
-            context.emitter.emit('complete', { success: true, summary, completion: context.completion });
-        },
-        assignCompletion: assign({
-            completion: ({ event }) => event.output,
-        }),
-    },
-    guards: {
-        shouldSkipAuth: ({ context }) => context.options.skipAuth === true,
-        gitIsClean: ({ context }) => context.gitIsClean === true,
-        hasCredentials: ({ context }) => context.options.apiKey !== undefined && context.options.clientId !== undefined,
-        hasIntegration: ({ context }) => context.integration !== undefined,
-        shouldSkipPostInstall: ({ context }) => context.options.noCommit === true,
-        hasGhCli: () => hasGhCli(),
-        // Read from the actor's done event (output), not context: the
-        // assignWorkspaceResult action has not run yet when guards are evaluated.
-        notScaffoldable: ({ event }) => !event.output?.scaffoldable,
-        shouldAutoScaffold: ({ event }) => {
-            const output = event.output;
-            return !!output?.scaffoldable && !!output?.autoScaffold;
-        },
-    },
-    actors: {
-        checkAuthentication: fromPromise(async () => {
-            throw new Error('checkAuthentication not implemented - provide via machine.provide()');
-        }),
-        checkWorkspace: fromPromise(async () => {
-            throw new Error('checkWorkspace not implemented - provide via machine.provide()');
-        }),
-        runScaffold: fromPromise(async () => {
-            throw new Error('runScaffold not implemented - provide via machine.provide()');
-        }),
-        detectIntegration: fromPromise(async () => {
-            throw new Error('detectIntegration not implemented - provide via machine.provide()');
-        }),
-        checkGitStatus: fromPromise(async () => {
-            throw new Error('checkGitStatus not implemented - provide via machine.provide()');
-        }),
-        configureEnvironment: fromPromise(async () => {
-            throw new Error('configureEnvironment not implemented - provide via machine.provide()');
-        }),
-        runAgent: fromPromise(async () => {
-            throw new Error('runAgent not implemented - provide via machine.provide()');
-        }),
-        buildCompletion: fromPromise(async () => {
-            throw new Error('buildCompletion not implemented - provide via machine.provide()');
-        }),
-        // Credential discovery actors
-        detectEnvFiles: fromPromise(async () => {
-            throw new Error('detectEnvFiles not implemented - provide via machine.provide()');
-        }),
-        scanEnvFiles: fromPromise(async () => {
-            throw new Error('scanEnvFiles not implemented - provide via machine.provide()');
-        }),
-        checkStoredAuth: fromPromise(async () => {
-            throw new Error('checkStoredAuth not implemented - provide via machine.provide()');
-        }),
-        runDeviceAuth: fromPromise(async () => {
-            throw new Error('runDeviceAuth not implemented - provide via machine.provide()');
-        }),
-        fetchStagingCredentials: fromPromise(async () => {
-            throw new Error('fetchStagingCredentials not implemented - provide via machine.provide()');
-        }),
-        // Branch check actors
-        checkBranch: fromPromise(async () => {
-            throw new Error('checkBranch not implemented - provide via machine.provide()');
-        }),
-        createBranch: fromPromise(async () => {
-            throw new Error('createBranch not implemented - provide via machine.provide()');
-        }),
-        // Post-install actors
-        detectChanges: fromPromise(async () => {
-            throw new Error('detectChanges not implemented - provide via machine.provide()');
-        }),
-        generateCommitMessage: fromPromise(async () => {
-            throw new Error('generateCommitMessage not implemented - provide via machine.provide()');
-        }),
-        commitChanges: fromPromise(async () => {
-            throw new Error('commitChanges not implemented - provide via machine.provide()');
-        }),
-        generatePrDescription: fromPromise(async () => {
-            throw new Error('generatePrDescription not implemented - provide via machine.provide()');
-        }),
-        pushBranch: fromPromise(async () => {
-            throw new Error('pushBranch not implemented - provide via machine.provide()');
-        }),
-        createPr: fromPromise(async () => {
-            throw new Error('createPr not implemented - provide via machine.provide()');
-        }),
-    },
-}).createMachine({
-    id: 'installer',
-    initial: 'idle',
-    context: ({ input }) => ({
-        emitter: input.emitter,
-        options: input.options,
-        // Set by the detection actor; no pre-seeding (the --integration flag is gone).
-        integration: undefined,
-        credentials: input.options.apiKey && input.options.clientId
-            ? { apiKey: input.options.apiKey, clientId: input.options.clientId }
-            : undefined,
-        gitIsClean: true,
-        gitDirtyFiles: [],
-        error: undefined,
-    }),
-    // Global event handlers - CANCEL can be sent from any state
-    on: {
-        CANCEL: {
-            target: '.cancelled',
-        },
-    },
-    states: {
-        idle: {
-            on: {
-                START: [
-                    {
-                        target: 'scaffold',
-                        guard: 'shouldSkipAuth',
-                        actions: { type: 'emitStateEnter', params: { state: 'scaffold' } },
-                    },
-                    {
-                        target: 'authenticating',
-                        actions: { type: 'emitStateEnter', params: { state: 'authenticating' } },
-                    },
-                ],
-            },
-        },
-        authenticating: {
-            entry: ['emitAuthChecking'],
-            invoke: {
-                id: 'checkAuthentication',
-                src: 'checkAuthentication',
-                input: ({ context }) => ({ options: context.options }),
-                onDone: {
-                    target: 'scaffold',
-                    actions: [
-                        'emitAuthSuccess',
-                        { type: 'emitStateExit', params: { state: 'authenticating' } },
-                        { type: 'emitStateEnter', params: { state: 'scaffold' } },
-                    ],
-                },
-                onError: {
-                    target: 'error',
-                    actions: ['assignError', 'emitAuthFailure', { type: 'emitStateExit', params: { state: 'authenticating' } }],
-                },
-            },
-        },
-        scaffold: {
-            initial: 'checking',
-            states: {
-                checking: {
-                    entry: ['emitScaffoldChecking'],
-                    invoke: {
-                        id: 'checkWorkspace',
-                        src: 'checkWorkspace',
-                        input: ({ context }) => ({ options: context.options }),
-                        onDone: [
-                            {
-                                // Not an empty dir: fall through to today's behavior.
-                                target: 'done',
-                                guard: 'notScaffoldable',
-                                actions: ['assignWorkspaceResult'],
-                            },
-                            {
-                                // Headless or --scaffold: skip the prompt.
-                                target: 'running',
-                                guard: 'shouldAutoScaffold',
-                                actions: ['assignWorkspaceResult'],
-                            },
-                            {
-                                // Interactive empty dir: ask first.
-                                target: 'prompting',
-                                actions: ['assignWorkspaceResult'],
-                            },
-                        ],
-                        onError: {
-                            // Workspace check failure is non-fatal: proceed to preparing,
-                            // which errors on no-integration exactly as before this feature.
-                            target: 'done',
-                        },
-                    },
-                },
-                prompting: {
-                    entry: ['emitScaffoldPrompt'],
-                    on: {
-                        SCAFFOLD_CONFIRMED: {
-                            target: 'running',
-                        },
-                        SCAFFOLD_CANCELLED: {
-                            target: '#installer.cancelled',
-                            actions: ['emitScaffoldSkipped', { type: 'emitStateExit', params: { state: 'scaffold' } }],
-                        },
-                    },
-                },
-                running: {
-                    entry: ['emitScaffoldStart'],
-                    invoke: {
-                        id: 'runScaffold',
-                        src: 'runScaffold',
-                        input: ({ context }) => ({ context }),
-                        onDone: {
-                            target: 'done',
-                            actions: ['assignScaffolded', 'emitScaffoldComplete'],
-                        },
-                        onError: {
-                            target: '#installer.error',
-                            actions: ['assignError', 'emitScaffoldFailed', { type: 'emitStateExit', params: { state: 'scaffold' } }],
-                        },
-                    },
-                },
-                done: {
-                    type: 'final',
-                },
-            },
-            onDone: {
-                target: 'preparing',
-                actions: [
-                    { type: 'emitStateExit', params: { state: 'scaffold' } },
-                    { type: 'emitStateEnter', params: { state: 'preparing' } },
-                ],
-            },
-        },
-        preparing: {
-            type: 'parallel',
-            states: {
-                detection: {
-                    initial: 'running',
-                    states: {
-                        running: {
-                            entry: ['emitDetectionStart'],
-                            invoke: {
-                                id: 'detectIntegration',
-                                src: 'detectIntegration',
-                                input: ({ context }) => ({ options: context.options }),
-                                onDone: {
-                                    target: 'done',
-                                    actions: ['assignDetectionResult', 'emitDetectionComplete'],
-                                },
-                                onError: {
-                                    // Detection failure is non-fatal - user can select manually
-                                    target: 'done',
-                                    actions: ['emitDetectionComplete'],
-                                },
-                            },
-                        },
-                        done: {
-                            type: 'final',
-                        },
-                    },
-                },
-                gitCheck: {
-                    initial: 'running',
-                    states: {
-                        running: {
-                            entry: ['emitGitChecking'],
-                            invoke: {
-                                id: 'checkGitStatus',
-                                src: 'checkGitStatus',
-                                input: ({ context }) => ({ installDir: context.options.installDir }),
-                                onDone: {
-                                    target: 'evaluating',
-                                    actions: ['assignGitResult'],
-                                },
-                                onError: {
-                                    // Git check failure is non-fatal - treat as clean
-                                    target: 'done',
-                                },
-                            },
-                        },
-                        evaluating: {
-                            always: [
-                                {
-                                    target: 'done',
-                                    guard: 'gitIsClean',
-                                    actions: ['emitGitClean'],
-                                },
-                                {
-                                    target: 'awaitingConfirmation',
-                                    actions: ['emitGitDirty'],
-                                },
-                            ],
-                        },
-                        awaitingConfirmation: {
-                            on: {
-                                GIT_CONFIRMED: {
-                                    target: 'done',
-                                    actions: ['emitGitConfirmed'],
-                                },
-                                GIT_CANCELLED: {
-                                    target: '#installer.cancelled',
-                                    actions: ['emitGitCancelled'],
-                                },
-                            },
-                        },
-                        done: {
-                            type: 'final',
-                        },
-                    },
-                },
-                branchCheck: {
-                    initial: 'running',
-                    states: {
-                        running: {
-                            entry: ['emitBranchChecking'],
-                            invoke: {
-                                id: 'checkBranch',
-                                src: 'checkBranch',
-                                onDone: [
-                                    {
-                                        target: 'awaitingConfirmation',
-                                        guard: ({ event }) => event.output.isProtected,
-                                        actions: ['assignBranchResult', 'emitBranchProtected'],
-                                    },
-                                    {
-                                        target: 'done',
-                                        actions: ['assignBranchResult'],
-                                    },
-                                ],
-                                onError: {
-                                    // Branch check failure is non-fatal
-                                    target: 'done',
-                                },
-                            },
-                        },
-                        awaitingConfirmation: {
-                            on: {
-                                BRANCH_CREATE: {
-                                    target: 'creating',
-                                },
-                                BRANCH_CONTINUE: {
-                                    target: 'done',
-                                },
-                                BRANCH_CANCEL: {
-                                    target: '#installer.cancelled',
-                                },
-                            },
-                        },
-                        creating: {
-                            invoke: {
-                                id: 'createBranch',
-                                src: 'createBranch',
-                                input: () => ({
-                                    name: 'feat/add-workos-authkit',
-                                    fallbackName: `feat/add-workos-authkit-${Date.now()}`,
-                                }),
-                                onDone: {
-                                    target: 'done',
-                                    actions: [
-                                        {
-                                            type: 'emitBranchCreated',
-                                            params: ({ event }) => ({ branch: event.output.branch }),
-                                        },
-                                    ],
-                                },
-                                onError: {
-                                    // Branch creation failure is non-fatal
-                                    target: 'done',
-                                    actions: ['assignError', 'emitBranchCreateFailed'],
-                                },
-                            },
-                        },
-                        done: {
-                            type: 'final',
-                        },
-                    },
-                },
-            },
-            onDone: [
-                {
-                    target: 'gatheringCredentials',
-                    guard: 'hasIntegration',
-                    actions: { type: 'emitStateExit', params: { state: 'preparing' } },
-                },
-                {
-                    target: 'error',
-                    actions: [
-                        assign({
-                            error: ({ context }) => {
-                                const dir = context.options.installDir;
-                                return new Error(`No supported framework was detected in ${dir}.\n` +
-                                    `Because this directory isn't empty, a new app wasn't scaffolded, and no recognized ` +
-                                    `framework (such as a package.json with Next.js) was found to install into.\n\n` +
-                                    `Next steps:\n` +
-                                    `  - New app: run \`${formatWorkOSCommand('install')}\` in an empty directory to scaffold Next.js + AuthKit.\n` +
-                                    `  - Existing project: run from the directory that contains your package.json, or pass --install-dir <path>.`);
-                            },
-                        }),
-                        { type: 'emitStateExit', params: { state: 'preparing' } },
-                    ],
-                },
-            ],
-        },
-        gatheringCredentials: {
-            entry: [{ type: 'emitStateEnter', params: { state: 'gatheringCredentials' } }],
-            initial: 'checkingCliFlags',
-            states: {
-                // Step 1: Check CLI flags (highest priority)
-                checkingCliFlags: {
-                    always: [
-                        {
-                            target: '#installer.configuring',
-                            guard: 'hasCredentials',
-                            actions: [
-                                assign({ credentialSource: () => 'cli' }),
-                                'emitCredentialsFound',
-                                { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
-                            ],
-                        },
-                        { target: 'detectingEnvFiles' },
-                    ],
-                },
-                // Step 2: Check if env files exist (don't read yet)
-                detectingEnvFiles: {
-                    invoke: {
-                        id: 'detectEnvFiles',
-                        src: 'detectEnvFiles',
-                        input: ({ context }) => ({ installDir: context.options.installDir }),
-                        onDone: [
-                            {
-                                target: 'promptingEnvScan',
-                                guard: ({ event }) => {
-                                    const output = event.output;
-                                    return output.exists;
-                                },
-                                actions: [
-                                    assign({
-                                        envFilesDetected: ({ event }) => {
-                                            const output = event.output;
-                                            return output.files;
-                                        },
-                                    }),
-                                    'emitEnvDetected',
-                                ],
-                            },
-                            { target: 'checkingStoredAuth' },
-                        ],
-                        onError: {
-                            target: 'checkingStoredAuth', // Non-fatal, continue
-                        },
-                    },
-                },
-                // Step 3: Ask user for consent to scan env files
-                promptingEnvScan: {
-                    entry: ['emitEnvScanPrompt'],
-                    on: {
-                        ENV_SCAN_APPROVED: {
-                            target: 'scanningEnvFiles',
-                            actions: assign({ envScanConsent: () => true }),
-                        },
-                        ENV_SCAN_DECLINED: {
-                            target: 'checkingStoredAuth',
-                            actions: assign({ envScanConsent: () => false }),
-                        },
-                        CANCEL: {
-                            target: '#installer.cancelled',
-                            actions: { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
-                        },
-                    },
-                },
-                // Step 4: Scan env files for credentials (with consent)
-                scanningEnvFiles: {
-                    entry: ['emitEnvScanning'],
-                    invoke: {
-                        id: 'scanEnvFiles',
-                        src: 'scanEnvFiles',
-                        input: ({ context }) => ({ installDir: context.options.installDir }),
-                        onDone: [
-                            {
-                                target: '#installer.configuring',
-                                guard: ({ event }) => {
-                                    const result = event.output;
-                                    return result.found && !!result.clientId;
-                                },
-                                actions: [
-                                    assign({
-                                        credentials: ({ event }) => {
-                                            const result = event.output;
-                                            return { clientId: result.clientId, apiKey: result.apiKey };
-                                        },
-                                        credentialSource: () => 'env',
-                                        envCredentialPath: ({ event }) => event.output.sourcePath,
-                                    }),
-                                    'emitEnvCredentialsFound',
-                                    { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
-                                ],
-                            },
-                            {
-                                target: 'checkingStoredAuth',
-                                actions: ['emitEnvNotFound'],
-                            },
-                        ],
-                        onError: {
-                            target: 'checkingStoredAuth',
-                        },
-                    },
-                },
-                // Step 5: Check for stored auth token
-                checkingStoredAuth: {
-                    invoke: {
-                        id: 'checkStoredAuth',
-                        src: 'checkStoredAuth',
-                        onDone: [
-                            {
-                                target: 'fetchingStagingCredentials',
-                                guard: ({ event }) => event.output === true,
-                            },
-                            { target: 'runningDeviceAuth' },
-                        ],
-                        onError: {
-                            target: 'runningDeviceAuth',
-                        },
-                    },
-                },
-                // Step 6: Run device authorization flow
-                runningDeviceAuth: {
-                    entry: ['emitDeviceAuthStart'],
-                    invoke: {
-                        id: 'runDeviceAuth',
-                        src: 'runDeviceAuth',
-                        input: ({ context }) => ({ emitter: context.emitter }),
-                        onDone: {
-                            target: 'fetchingStagingCredentials',
-                            actions: [
-                                'emitDeviceAuthSuccess',
-                                assign({
-                                    deviceAuth: ({ event }) => {
-                                        const output = event.output;
-                                        return {
-                                            verificationUri: output.deviceAuth.verification_uri,
-                                            verificationUriComplete: output.deviceAuth.verification_uri_complete,
-                                            userCode: output.deviceAuth.user_code,
-                                        };
-                                    },
-                                }),
-                            ],
-                        },
-                        onError: {
-                            target: 'promptingManual',
-                            actions: ['assignError', 'emitDeviceAuthError'],
-                        },
-                    },
-                },
-                // Step 7: Fetch staging credentials from API
-                fetchingStagingCredentials: {
-                    entry: ['emitStagingFetching'],
-                    invoke: {
-                        id: 'fetchStagingCredentials',
-                        src: 'fetchStagingCredentials',
-                        onDone: {
-                            target: '#installer.configuring',
-                            actions: [
-                                assign({
-                                    credentials: ({ event }) => {
-                                        const staging = event.output;
-                                        return { clientId: staging.clientId, apiKey: staging.apiKey };
-                                    },
-                                    credentialSource: ({ context }) => context.deviceAuth ? 'device' : 'stored',
-                                }),
-                                'emitStagingSuccess',
-                                { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
-                            ],
-                        },
-                        onError: {
-                            target: 'promptingManual',
-                            actions: ['assignError', 'emitStagingError'],
-                        },
-                    },
-                },
-                // Step 8: Manual fallback
-                promptingManual: {
-                    entry: ['emitCredentialsGathering'],
-                    on: {
-                        CREDENTIALS_SUBMITTED: {
-                            target: '#installer.configuring',
-                            actions: [
-                                'assignCredentials',
-                                assign({ credentialSource: () => 'manual' }),
-                                { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
-                            ],
-                        },
-                        RETRY_AUTH: {
-                            target: 'runningDeviceAuth',
-                        },
-                        CANCEL: {
-                            target: '#installer.cancelled',
-                            actions: { type: 'emitStateExit', params: { state: 'gatheringCredentials' } },
-                        },
-                    },
-                },
-            },
-        },
-        configuring: {
-            entry: [{ type: 'emitStateEnter', params: { state: 'configuring' } }, 'emitConfigStart'],
-            invoke: {
-                id: 'configureEnvironment',
-                src: 'configureEnvironment',
-                input: ({ context }) => ({ context }),
-                onDone: {
-                    target: 'runningAgent',
-                    actions: ['emitConfigComplete', { type: 'emitStateExit', params: { state: 'configuring' } }],
-                },
-                onError: {
-                    target: 'error',
-                    actions: ['assignError', { type: 'emitStateExit', params: { state: 'configuring' } }],
-                },
-            },
-        },
-        runningAgent: {
-            entry: [{ type: 'emitStateEnter', params: { state: 'runningAgent' } }, 'emitAgentStart'],
-            invoke: {
-                id: 'runAgent',
-                src: 'runAgent',
-                input: ({ context }) => ({ context }),
-                onDone: [
-                    {
-                        target: 'error',
-                        guard: ({ event }) => {
-                            const output = event.output;
-                            return !output.success;
-                        },
-                        actions: [
-                            ({ context, event }) => {
-                                const output = event.output;
-                                context.emitter.emit('agent:failure', {
-                                    message: output.error?.message ?? 'Agent failed',
-                                });
-                            },
-                            assign({
-                                error: ({ event }) => {
-                                    const output = event.output;
-                                    return output.error ?? new Error('Agent failed');
-                                },
-                            }),
-                            { type: 'emitStateExit', params: { state: 'runningAgent' } },
-                        ],
-                    },
-                    {
-                        target: 'postInstall',
-                        actions: [
-                            assign({
-                                agentSummary: ({ event }) => {
-                                    const output = event.output;
-                                    return output.summary;
-                                },
-                            }),
-                            ({ context, event }) => {
-                                const output = event.output;
-                                context.emitter.emit('agent:success', { summary: output.summary });
-                            },
-                            { type: 'emitStateExit', params: { state: 'runningAgent' } },
-                        ],
-                    },
-                ],
-                onError: {
-                    target: 'error',
-                    actions: ['assignError', 'emitAgentFailure', { type: 'emitStateExit', params: { state: 'runningAgent' } }],
-                },
-            },
-        },
-        postInstall: {
-            initial: 'checking',
-            entry: [{ type: 'emitStateEnter', params: { state: 'postInstall' } }],
-            states: {
-                checking: {
-                    always: [
-                        {
-                            target: '#installer.buildingCompletion',
-                            guard: 'shouldSkipPostInstall',
-                        },
-                        { target: 'detectingChanges' },
-                    ],
-                },
-                detectingChanges: {
-                    invoke: {
-                        id: 'detectChanges',
-                        src: 'detectChanges',
-                        onDone: [
-                            {
-                                target: 'promptingCommit',
-                                guard: ({ event }) => event.output.hasChanges,
-                                actions: ['assignChangedFiles', 'emitChangesDetected'],
-                            },
-                            {
-                                target: 'done',
-                                actions: ['emitNoChanges'],
-                            },
-                        ],
-                        onError: { target: 'done' },
-                    },
-                },
-                promptingCommit: {
-                    entry: ['emitCommitPrompt'],
-                    on: {
-                        COMMIT_APPROVED: { target: 'generatingCommitMessage' },
-                        COMMIT_DECLINED: { target: 'done' },
-                        CANCEL: { target: '#installer.cancelled' },
-                    },
-                },
-                generatingCommitMessage: {
-                    entry: ['emitGeneratingCommitMessage'],
-                    invoke: {
-                        id: 'generateCommitMessage',
-                        src: 'generateCommitMessage',
-                        input: ({ context }) => ({
-                            integration: context.integration ?? 'project',
-                            files: context.changedFiles ?? [],
-                            direct: context.options.direct,
-                        }),
-                        onDone: {
-                            target: 'committing',
-                            actions: ['assignCommitMessage'],
-                        },
-                    },
-                },
-                committing: {
-                    entry: ['emitCommitting'],
-                    invoke: {
-                        id: 'commitChanges',
-                        src: 'commitChanges',
-                        input: ({ context }) => ({
-                            message: context.commitMessage ?? '',
-                            cwd: context.options.installDir,
-                        }),
-                        onDone: {
-                            target: 'checkingGhCli',
-                            actions: ['emitCommitSuccess'],
-                        },
-                        onError: {
-                            target: 'done',
-                            actions: ['assignError', 'emitCommitFailed'],
-                        },
-                    },
-                },
-                checkingGhCli: {
-                    always: [
-                        {
-                            target: 'promptingPr',
-                            guard: 'hasGhCli',
-                        },
-                        {
-                            target: 'showingManualInstructions',
-                        },
-                    ],
-                },
-                promptingPr: {
-                    entry: ['emitPrPrompt'],
-                    on: {
-                        PR_APPROVED: { target: 'generatingPrDescription' },
-                        PR_DECLINED: { target: 'done' },
-                        CANCEL: { target: '#installer.cancelled' },
-                    },
-                },
-                generatingPrDescription: {
-                    entry: ['emitGeneratingPrDescription'],
-                    invoke: {
-                        id: 'generatePrDescription',
-                        src: 'generatePrDescription',
-                        input: ({ context }) => ({
-                            integration: context.integration ?? 'project',
-                            files: context.changedFiles ?? [],
-                            commitMessage: context.commitMessage ?? '',
-                            direct: context.options.direct,
-                        }),
-                        onDone: {
-                            target: 'pushing',
-                            actions: ['assignPrDescription'],
-                        },
-                    },
-                },
-                pushing: {
-                    entry: ['emitPushing'],
-                    invoke: {
-                        id: 'pushBranch',
-                        src: 'pushBranch',
-                        input: ({ context }) => ({ cwd: context.options.installDir }),
-                        onDone: { target: 'creatingPr' },
-                        onError: {
-                            target: 'showingManualInstructions',
-                            actions: ['assignError', 'emitPushFailed'],
-                        },
-                    },
-                },
-                creatingPr: {
-                    entry: ['emitCreatingPr'],
-                    invoke: {
-                        id: 'createPr',
-                        src: 'createPr',
-                        input: ({ context }) => ({
-                            title: context.commitMessage ?? '',
-                            body: context.prDescription ?? '',
-                            cwd: context.options.installDir,
-                        }),
-                        onDone: {
-                            target: 'done',
-                            actions: ['assignPrUrl', 'emitPrCreated'],
-                        },
-                        onError: {
-                            target: 'done',
-                            actions: ['assignError', 'emitPrFailed'],
-                        },
-                    },
-                },
-                showingManualInstructions: {
-                    entry: ['emitManualInstructions'],
-                    always: { target: 'done' },
-                },
-                done: {
-                    type: 'final',
-                },
-            },
-            onDone: {
-                target: 'buildingCompletion',
-            },
-        },
-        // Compute the structured completion payload before entering `complete`.
-        // `emitComplete` is a synchronous entry action, but the builder is async
-        // (lockfile-aware dev command, port detection), so it must run in an actor
-        // first. Errors never block completion — they fall through to the static box.
-        buildingCompletion: {
-            invoke: {
-                src: 'buildCompletion',
-                input: ({ context }) => ({ context }),
-                onDone: { target: 'complete', actions: ['assignCompletion'] },
-                onError: { target: 'complete' },
-            },
-        },
-        complete: {
-            type: 'final',
-            entry: [{ type: 'emitStateEnter', params: { state: 'complete' } }, 'emitComplete'],
-        },
-        cancelled: {
-            type: 'final',
-            entry: [{ type: 'emitStateEnter', params: { state: 'cancelled' } }, 'emitCancelled'],
-        },
-        error: {
-            type: 'final',
-            entry: [{ type: 'emitStateEnter', params: { state: 'error' } }, 'emitError'],
-        },
-    },
-});
-//# sourceMappingURL=installer-core.js.map