workos 0.19.0 → 0.20.2

package/dist/lib/run-with-core.js

@@ -1,559 +0,0 @@
-import { createActor, fromPromise } from 'xstate';
-import open from 'open';
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { installerMachine } from './installer-core.js';
-import { createInstallerEventEmitter } from './events.js';
-import { buildCompletionData } from './completion-data.js';
-import { resolveDevCommand } from './dev-command.js';
-import { getConfig as getInstallerSettings } from './settings.js';
-import { CLIAdapter } from './adapters/cli-adapter.js';
-import { DashboardAdapter } from './adapters/dashboard-adapter.js';
-import { getInteractionMode, isAgentMode, isCiMode } from '../utils/interaction-mode.js';
-import { getOutputMode, isJsonMode, resolveEffectiveOutputMode, setOutputMode } from '../utils/output.js';
-import { isScaffoldableEmptyDir, resolvePackageManager, runCreateNextApp } from './scaffold/index.js';
-import { parseEnvFile } from '../utils/env-parser.js';
-import { enableDebugLogs, initLogFile, logInfo, logError } from '../utils/debug.js';
-import { getAccessToken, saveCredentials, getStagingCredentials, saveStagingCredentials } from './credentials.js';
-import { getConfig, saveConfig, getActiveEnvironment, isUnclaimedEnvironment } from './config-store.js';
-import { checkForEnvFiles, discoverCredentials } from './credential-discovery.js';
-import { requestDeviceCode, pollForToken } from './device-auth.js';
-import { fetchStagingCredentials as fetchStagingCredentialsApi } from './staging-api.js';
-import { getCliAuthClientId, getAuthkitDomain } from './settings.js';
-import { getTelemetryUrl } from '../utils/urls.js';
-import { analytics } from '../utils/analytics.js';
-import { getVersion } from './settings.js';
-import { isInGitRepo, getUncommittedOrUntrackedFiles } from '../utils/ui-utils.js';
-import { getCurrentBranch, isProtectedBranch, createBranch as createGitBranch, branchExists, } from '../utils/git-utils.js';
-import { detectChanges, stageAndCommit, pushBranch as pushGitBranch, createPullRequest } from './post-install.js';
-import { generateCommitMessage as generateCommitMessageAi, generatePrDescription as generatePrDescriptionAi, } from './ai-content.js';
-import { autoConfigureWorkOSEnvironment } from './workos-management.js';
-import { detectPort, getCallbackPath } from './port-detection.js';
-import { writeEnvLocal } from './env-writer.js';
-import { getRegistry } from './registry.js';
-import { observeHostFailure } from './host-probe.js';
-import { formatWorkOSCommand } from '../utils/command-invocation.js';
-async function runIntegrationInstallerFn(integration, options) {
-    const registry = await getRegistry();
-    const mod = registry.get(integration);
-    if (!mod) {
-        throw new Error(`Unknown integration: ${integration}`);
-    }
-    return mod.run(options);
-}
-function readExistingCredentials(installDir) {
-    const envPath = join(installDir, '.env.local');
-    if (!existsSync(envPath)) {
-        return {};
-    }
-    try {
-        const content = readFileSync(envPath, 'utf-8');
-        const envVars = parseEnvFile(content);
-        return {
-            apiKey: envVars.WORKOS_API_KEY || undefined,
-            clientId: envVars.WORKOS_CLIENT_ID || undefined,
-        };
-    }
-    catch {
-        return {};
-    }
-}
-async function detectIntegrationFn(options) {
-    const registry = await getRegistry();
-    const configs = registry.detectionOrder();
-    for (const config of configs) {
-        // Use the detect function from INTEGRATION_CONFIG in config.ts for JS integrations,
-        // or fall back to checking if the framework package is installed
-        const detected = await detectSingleIntegration(config.metadata.integration, options);
-        if (detected) {
-            return config.metadata.integration;
-        }
-    }
-    return undefined;
-}
-/**
- * Detect if a single integration matches the project.
- * Uses package.json detection for JS integrations, manifest files for others.
- */
-export async function detectSingleIntegration(integration, options) {
-    const { getPackageDotJson } = await import('../utils/ui-utils.js');
-    const { hasPackageInstalled } = await import('../utils/package-json.js');
-    const { existsSync } = await import('node:fs');
-    const { join } = await import('node:path');
-    const registry = await getRegistry();
-    const mod = registry.get(integration);
-    if (!mod)
-        return false;
-    const config = mod.config;
-    // For JS integrations, check package.json
-    if (config.metadata.language === 'javascript') {
-        // Without a package.json, no JS integration can match. Skip silently so
-        // non-JS integrations (Python/Django, Ruby, Go, ...) still get a chance —
-        // getPackageDotJson would otherwise call process.exit(1).
-        if (!existsSync(join(options.installDir, 'package.json'))) {
-            return false;
-        }
-        const packageJson = await getPackageDotJson(options);
-        switch (integration) {
-            case 'nextjs':
-                return hasPackageInstalled('next', packageJson);
-            case 'tanstack-start':
-                return hasPackageInstalled('@tanstack/react-start', packageJson);
-            case 'react-router':
-                return hasPackageInstalled('react-router', packageJson);
-            case 'react': {
-                const hasReact = hasPackageInstalled('react', packageJson);
-                const hasNext = hasPackageInstalled('next', packageJson);
-                const hasReactRouter = hasPackageInstalled('react-router', packageJson);
-                const hasTanstack = hasPackageInstalled('@tanstack/react-start', packageJson);
-                const hasSvelteKit = hasPackageInstalled('@sveltejs/kit', packageJson);
-                return hasReact && !hasNext && !hasReactRouter && !hasTanstack && !hasSvelteKit;
-            }
-            case 'sveltekit':
-                return hasPackageInstalled('@sveltejs/kit', packageJson);
-            case 'node': {
-                const hasExpress = hasPackageInstalled('express', packageJson);
-                const hasFrontend = hasPackageInstalled('next', packageJson) ||
-                    hasPackageInstalled('@sveltejs/kit', packageJson) ||
-                    hasPackageInstalled('react', packageJson) ||
-                    hasPackageInstalled('@tanstack/react-start', packageJson);
-                return hasExpress && !hasFrontend;
-            }
-            case 'vanilla-js':
-                return true; // Fallback
-            default:
-                // Unknown JS integration — try package name detection
-                return hasPackageInstalled(config.detection.packageName, packageJson);
-        }
-    }
-    // For non-JS integrations, prefer a custom detect() if provided
-    // (e.g., Django matches manage.py | pyproject.toml | requirements.txt),
-    // otherwise fall back to manifest file existence.
-    if (config.metadata.detect) {
-        return await config.metadata.detect(options);
-    }
-    if (config.metadata.manifestFile) {
-        return existsSync(join(options.installDir, config.metadata.manifestFile));
-    }
-    return false;
-}
-export async function runWithCore(options) {
-    // Initialize debug/logging early so we capture all failures
-    initLogFile();
-    if (options.debug) {
-        enableDebugLogs();
-    }
-    logInfo('Wizard starting with options:', {
-        debug: options.debug,
-        dashboard: options.dashboard,
-        local: options.local,
-        ci: options.ci,
-        skipAuth: options.skipAuth,
-        installDir: options.installDir,
-    });
-    // Configure telemetry endpoint separately from the LLM gateway proxy.
-    const gatewayUrl = getTelemetryUrl();
-    analytics.setGatewayUrl(gatewayUrl);
-    const existingCreds = readExistingCredentials(options.installDir);
-    const augmentedOptions = {
-        ...options,
-        apiKey: options.apiKey || existingCreds.apiKey,
-        clientId: options.clientId || existingCreds.clientId,
-    };
-    const emitter = createInstallerEventEmitter();
-    let actor = null;
-    const sendEvent = (event) => {
-        if (actor) {
-            actor.send(event);
-        }
-    };
-    const nonHumanMode = isAgentMode() || isCiMode();
-    if (nonHumanMode && !isJsonMode()) {
-        setOutputMode(resolveEffectiveOutputMode(getOutputMode(), getInteractionMode()));
-    }
-    // Headless (no prompts, structured output) is for MACHINE output only: JSON.
-    // A prompt cannot render into a JSON stream, so any JSON run must be headless.
-    // We deliberately do NOT route a human session with non-TTY stdin here:
-    // headless auto-approves branch/commit/scaffold, and applying those unattended
-    // to a session the user never opted into would violate the "nothing is written
-    // until you confirm" contract. Those sessions keep the CLIAdapter, which now
-    // fails fast with a clear `prompt_unavailable` error on the first prompt
-    // (see CLIAdapter's handler-error catch) instead of hanging or auto-writing.
-    // --dashboard keeps its own adapter even under --json.
-    const headlessMode = isJsonMode() && !options.dashboard;
-    let adapter;
-    if (headlessMode) {
-        const { HeadlessAdapter } = await import('./adapters/headless-adapter.js');
-        adapter = new HeadlessAdapter({
-            emitter,
-            sendEvent,
-            debug: augmentedOptions.debug,
-            options: {
-                apiKey: augmentedOptions.apiKey,
-                clientId: augmentedOptions.clientId,
-                noBranch: augmentedOptions.noBranch,
-                noCommit: augmentedOptions.noCommit,
-                createPr: augmentedOptions.createPr,
-                noGitCheck: augmentedOptions.noGitCheck,
-                ci: augmentedOptions.ci,
-            },
-        });
-    }
-    else if (options.dashboard) {
-        adapter = new DashboardAdapter({ emitter, sendEvent, debug: augmentedOptions.debug });
-    }
-    else {
-        adapter = new CLIAdapter({ emitter, sendEvent, debug: augmentedOptions.debug });
-    }
-    const machineWithActors = installerMachine.provide({
-        actors: {
-            checkAuthentication: fromPromise(async () => {
-                // Check for active environment with credentials (covers unclaimed environments).
-                const activeEnv = getActiveEnvironment();
-                if (activeEnv?.apiKey) {
-                    return true;
-                }
-                const token = getAccessToken();
-                if (!token) {
-                    // This should rarely happen since bin.ts handles auth first
-                    // But keep as safety net for programmatic usage
-                    throw new Error(`Not authenticated. Run \`${formatWorkOSCommand('auth login')}\` first.`);
-                }
-                return true;
-            }),
-            checkWorkspace: fromPromise(async ({ input }) => {
-                const scaffoldable = await isScaffoldableEmptyDir(input.options.installDir);
-                const packageManager = resolvePackageManager({
-                    pm: input.options.pm,
-                    userAgent: process.env.npm_config_user_agent,
-                });
-                // headlessMode is computed above; --scaffold opts in during interactive runs.
-                const autoScaffold = scaffoldable && (headlessMode || !!input.options.scaffold);
-                return { scaffoldable, packageManager, autoScaffold };
-            }),
-            runScaffold: fromPromise(async ({ input }) => {
-                const { options: installerOptions, packageManager, emitter: ctxEmitter } = input.context;
-                await runCreateNextApp({
-                    installDir: installerOptions.installDir,
-                    packageManager: packageManager ?? 'npm',
-                    emitter: ctxEmitter,
-                });
-            }),
-            detectIntegration: fromPromise(async ({ input }) => {
-                const integration = await detectIntegrationFn({ installDir: input.options.installDir });
-                return { integration };
-            }),
-            checkGitStatus: fromPromise(async () => {
-                if (!isInGitRepo()) {
-                    return { isClean: true, files: [] };
-                }
-                const files = getUncommittedOrUntrackedFiles();
-                return { isClean: files.length === 0, files };
-            }),
-            configureEnvironment: fromPromise(async ({ input }) => {
-                const { context } = input;
-                const { options: installerOptions, integration, credentials } = context;
-                if (!integration || !credentials) {
-                    throw new Error('Missing integration or credentials');
-                }
-                // Non-JS integrations own their env file writing (e.g. Python writes
-                // .env inside its own run()). Skip here so we don't leak a .env.local
-                // with JS-flavored vars (WORKOS_COOKIE_PASSWORD, wrong redirect port).
-                const registry = await getRegistry();
-                const mod = registry.get(integration);
-                if (mod?.config.metadata.language !== 'javascript') {
-                    return;
-                }
-                const port = detectPort(integration, installerOptions.installDir);
-                const callbackPath = getCallbackPath(integration);
-                const redirectUri = installerOptions.redirectUri || `http://localhost:${port}${callbackPath}`;
-                const requiresApiKey = ['nextjs', 'tanstack-start', 'react-router'].includes(integration);
-                if (credentials.apiKey && requiresApiKey) {
-                    await autoConfigureWorkOSEnvironment(credentials.apiKey, integration, port, {
-                        homepageUrl: installerOptions.homepageUrl,
-                        redirectUri: installerOptions.redirectUri,
-                    });
-                }
-                const redirectUriKey = integration === 'nextjs' ? 'NEXT_PUBLIC_WORKOS_REDIRECT_URI' : 'WORKOS_REDIRECT_URI';
-                writeEnvLocal(installerOptions.installDir, {
-                    ...(credentials.apiKey ? { WORKOS_API_KEY: credentials.apiKey } : {}),
-                    WORKOS_CLIENT_ID: credentials.clientId,
-                    [redirectUriKey]: redirectUri,
-                });
-            }),
-            runAgent: fromPromise(async ({ input }) => {
-                const { context } = input;
-                const { options: installerOptions, integration, credentials } = context;
-                if (!integration) {
-                    return { success: false, error: new Error('No integration specified') };
-                }
-                try {
-                    const agentOptions = {
-                        ...installerOptions,
-                        apiKey: credentials?.apiKey,
-                        clientId: credentials?.clientId,
-                        credentialSource: context.credentialSource,
-                        emitter: context.emitter,
-                    };
-                    const summary = await runIntegrationInstallerFn(integration, agentOptions);
-                    return {
-                        success: true,
-                        summary: summary || `Successfully installed WorkOS AuthKit for ${integration}!`,
-                    };
-                }
-                catch (error) {
-                    return {
-                        success: false,
-                        error: error instanceof Error ? error : new Error(String(error)),
-                    };
-                }
-            }),
-            buildCompletion: fromPromise(async ({ input }) => {
-                const { integration, changedFiles, options: installerOptions } = input.context;
-                if (!integration)
-                    return undefined;
-                try {
-                    const registry = await getRegistry();
-                    const mod = registry.get(integration);
-                    const cfg = mod?.config;
-                    const settings = getInstallerSettings();
-                    return await buildCompletionData({ integration, changedFiles, installDir: installerOptions.installDir }, {
-                        resolveDevCommand,
-                        detectPort,
-                        docsUrl: cfg?.metadata.docsUrl ?? settings.documentation.workosDocsUrl,
-                        dashboardUrl: settings.documentation.dashboardUrl,
-                        frameworkNextSteps: cfg?.ui.getOutroNextSteps?.({}) ?? [],
-                        signInSnippet: cfg?.ui.getSignInSnippet?.({}),
-                    });
-                }
-                catch {
-                    // Degrade to the static fallback box rather than blocking completion.
-                    return undefined;
-                }
-            }),
-            // Credential discovery actors
-            detectEnvFiles: fromPromise(async ({ input }) => {
-                return checkForEnvFiles(input.installDir);
-            }),
-            scanEnvFiles: fromPromise(async ({ input }) => {
-                return discoverCredentials(input.installDir);
-            }),
-            checkStoredAuth: fromPromise(async () => {
-                const activeEnv = getActiveEnvironment();
-                if (activeEnv?.apiKey && isUnclaimedEnvironment(activeEnv)) {
-                    return true;
-                }
-                const token = getAccessToken();
-                return token !== null;
-            }),
-            runDeviceAuth: fromPromise(async ({ input }) => {
-                const clientId = getCliAuthClientId();
-                const authkitDomain = getAuthkitDomain();
-                const deviceAuth = await requestDeviceCode({
-                    clientId,
-                    authkitDomain,
-                });
-                // Emit device started event with verification info
-                input.emitter.emit('device:started', {
-                    verificationUri: deviceAuth.verification_uri,
-                    verificationUriComplete: deviceAuth.verification_uri_complete,
-                    userCode: deviceAuth.user_code,
-                });
-                // Open browser
-                try {
-                    const { default: openFn } = await import('open');
-                    await openFn(deviceAuth.verification_uri_complete, { wait: false });
-                }
-                catch (error) {
-                    observeHostFailure('browser-launch', error, {
-                        operation: 'open',
-                        target: deviceAuth.verification_uri_complete,
-                        label: 'installer device auth browser',
-                    });
-                    // User can open manually
-                }
-                const result = await pollForToken(deviceAuth.device_code, {
-                    clientId,
-                    authkitDomain,
-                    interval: deviceAuth.interval,
-                    onPoll: () => input.emitter.emit('device:polling', {}),
-                });
-                // Save the auth token
-                saveCredentials({
-                    accessToken: result.accessToken,
-                    expiresAt: result.expiresAt,
-                    userId: result.userId,
-                    email: result.email,
-                    refreshToken: result.refreshToken,
-                });
-                return { result, deviceAuth };
-            }),
-            fetchStagingCredentials: fromPromise(async () => {
-                const activeEnv = getActiveEnvironment();
-                if (activeEnv?.clientId && activeEnv?.apiKey) {
-                    return { clientId: activeEnv.clientId, apiKey: activeEnv.apiKey };
-                }
-                const cached = getStagingCredentials();
-                if (cached)
-                    return cached;
-                const token = getAccessToken();
-                if (!token)
-                    throw new Error('No access token available');
-                const staging = await fetchStagingCredentialsApi(token);
-                saveStagingCredentials(staging);
-                try {
-                    const config = getConfig() ?? { environments: {} };
-                    if (!config.environments['default']) {
-                        config.environments['default'] = {
-                            name: 'default',
-                            type: staging.apiKey.startsWith('sk_test_') ? 'sandbox' : 'production',
-                            apiKey: staging.apiKey,
-                            clientId: staging.clientId,
-                        };
-                        if (!config.activeEnvironment) {
-                            config.activeEnvironment = 'default';
-                        }
-                        saveConfig(config);
-                    }
-                }
-                catch {
-                    // Don't block install if config-store write fails
-                }
-                return staging;
-            }),
-            // Branch check actors
-            checkBranch: fromPromise(async () => {
-                const branch = getCurrentBranch();
-                if (!branch) {
-                    return { branch: null, isProtected: false };
-                }
-                return {
-                    branch,
-                    isProtected: isProtectedBranch(branch),
-                };
-            }),
-            createBranch: fromPromise(async ({ input }) => {
-                const { name, fallbackName } = input;
-                const targetBranch = branchExists(name) ? fallbackName : name;
-                createGitBranch(targetBranch);
-                return { branch: targetBranch };
-            }),
-            // Post-install actors
-            detectChanges: fromPromise(async () => {
-                return detectChanges();
-            }),
-            generateCommitMessage: fromPromise(async ({ input }) => {
-                return generateCommitMessageAi(input.integration, input.files, { direct: input.direct });
-            }),
-            commitChanges: fromPromise(async ({ input }) => {
-                stageAndCommit(input.message, input.cwd);
-            }),
-            generatePrDescription: fromPromise(async ({ input }) => {
-                return generatePrDescriptionAi(input.integration, input.files, input.commitMessage, { direct: input.direct });
-            }),
-            pushBranch: fromPromise(async ({ input }) => {
-                pushGitBranch(input.cwd);
-            }),
-            createPr: fromPromise(async ({ input }) => {
-                return createPullRequest(input.title, input.body, input.cwd);
-            }),
-        },
-    });
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let inspector;
-    if (augmentedOptions.inspect) {
-        const originalLog = console.log;
-        let inspectUrl;
-        console.log = (...args) => {
-            const msg = args.join(' ');
-            if (typeof msg === 'string' && msg.startsWith('https://stately.ai/inspect/')) {
-                inspectUrl = msg;
-                console.log = originalLog;
-                console.log(`Opening XState inspector: ${inspectUrl}`);
-                void open(inspectUrl).catch((error) => {
-                    observeHostFailure('browser-launch', error, {
-                        operation: 'open',
-                        target: inspectUrl,
-                        label: 'XState inspector browser',
-                    });
-                });
-            }
-            else {
-                originalLog.apply(console, args);
-            }
-        };
-        // Dynamic import - @statelyai/inspect is a devDependency
-        const { createSkyInspector } = await import('@statelyai/inspect');
-        inspector = createSkyInspector();
-        setTimeout(() => {
-            console.log = originalLog;
-        }, 5000).unref();
-    }
-    actor = createActor(machineWithActors, {
-        input: { emitter, options: augmentedOptions },
-        inspect: inspector?.inspect,
-    });
-    await adapter.start();
-    analytics.configureAuthFromAvailableSources();
-    const mode = headlessMode ? 'headless' : augmentedOptions.dashboard ? 'tui' : 'cli';
-    analytics.sessionStart(mode, getVersion());
-    let installerStatus = 'success';
-    // Handle ctrl+c by sending CANCEL to state machine for graceful shutdown
-    const handleSigint = () => {
-        installerStatus = 'cancelled';
-        actor?.send({ type: 'CANCEL' });
-    };
-    process.on('SIGINT', handleSigint);
-    try {
-        await new Promise((resolve, reject) => {
-            actor.subscribe({
-                complete: () => {
-                    const snapshot = actor.getSnapshot();
-                    if (snapshot.value === 'error') {
-                        const err = snapshot.context.error;
-                        installerStatus = 'error';
-                        reject(err ?? new Error('Wizard failed'));
-                    }
-                    else if (snapshot.value === 'cancelled') {
-                        installerStatus = 'cancelled';
-                        resolve();
-                    }
-                    else {
-                        resolve();
-                    }
-                },
-                error: (err) => {
-                    installerStatus = 'error';
-                    reject(err);
-                },
-            });
-            actor.start();
-            actor.send({ type: 'START' });
-        });
-    }
-    catch (error) {
-        installerStatus = 'error';
-        logError('Wizard failed with error:', error instanceof Error ? error.stack || error.message : String(error));
-        throw error;
-    }
-    finally {
-        process.off('SIGINT', handleSigint);
-        // Record the detected framework so session.end carries it (and the API can
-        // tag install metrics by integration). Known only after detection runs, so
-        // it's read from the final machine snapshot here; absent if the session
-        // aborted before detection.
-        const finalContext = actor?.getSnapshot().context;
-        const detectedIntegration = finalContext?.integration;
-        if (detectedIntegration) {
-            analytics.setTag('installer.integration', detectedIntegration);
-        }
-        // Record whether the empty-dir flow scaffolded a new app, so session.end
-        // carries it for adoption + scaffold-failure tracking.
-        if (finalContext?.scaffolded) {
-            analytics.setTag('scaffolded', true);
-        }
-        await analytics.shutdown(installerStatus);
-        await adapter.stop();
-    }
-}
-//# sourceMappingURL=run-with-core.js.map