fraim-framework 2.0.124 → 2.0.127

package/dist/src/core/utils/job-aliases.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEPRECATED_FRAIM_JOB_NAMES = void 0;
+exports.resolveFraimJobName = resolveFraimJobName;
+exports.isListableFraimJob = isListableFraimJob;
+const DEPRECATED_TO_CANONICAL_JOB_MAP = {
+    'learn-and-scale': 'upskill-employee',
+    'model-behavior': 'upskill-employee',
+    'promote-learning': 'upskill-employee',
+    'refine-jobs': 'upskill-employee',
+    'refine-skills': 'upskill-employee'
+};
+const DIRECT_JOB_ALIASES = {
+    'sleep on learnings': 'sleep-on-learnings'
+};
+exports.DEPRECATED_FRAIM_JOB_NAMES = new Set(Object.keys(DEPRECATED_TO_CANONICAL_JOB_MAP));
+function normalizeJobLookupInput(input) {
+    return input.trim().toLowerCase().replace(/[_\s]+/g, '-');
+}
+function resolveFraimJobName(input) {
+    const normalizedJobName = normalizeJobLookupInput(input);
+    const directAliasTarget = DIRECT_JOB_ALIASES[input.trim().toLowerCase()];
+    if (directAliasTarget) {
+        return {
+            requestedJobName: input,
+            normalizedJobName,
+            canonicalJobName: directAliasTarget
+        };
+    }
+    const deprecatedAliasTarget = DEPRECATED_TO_CANONICAL_JOB_MAP[normalizedJobName];
+    if (deprecatedAliasTarget) {
+        return {
+            requestedJobName: input,
+            normalizedJobName,
+            canonicalJobName: deprecatedAliasTarget,
+            deprecatedAliasTarget
+        };
+    }
+    return {
+        requestedJobName: input,
+        normalizedJobName,
+        canonicalJobName: normalizedJobName
+    };
+}
+function isListableFraimJob(jobName) {
+    return !exports.DEPRECATED_FRAIM_JOB_NAMES.has(normalizeJobLookupInput(jobName));
+}

package/dist/src/core/utils/workflow-parser.js

@@ -5,15 +5,13 @@ const fs_1 = require("fs");
 const path_1 = require("path");
 class WorkflowParser {
     static extractMetadataBlock(content) {
-        // Allow leading comments and whitespace before frontmatter
-        const frontmatterMatch = content.match(/^[\s\S]*?---\r?\n([\s\S]+?)\r?\n---/);
+        const frontmatterMatch = content.match(/^---\r?\n([\s\S]+?)\r?\n---/);
         if (frontmatterMatch) {
             try {
-                const startIndex = frontmatterMatch.index || 0;
                 return {
                     state: 'valid',
                     metadata: JSON.parse(frontmatterMatch[1]),
-                    bodyStartIndex: startIndex + frontmatterMatch[0].length
+                    bodyStartIndex: frontmatterMatch[0].length
                 };
             }
             catch {
@@ -109,7 +107,7 @@ class WorkflowParser {
             overview = contentAfterMetadata;
         }
         const phases = new Map();
-        const phaseSections = restOfContent.split(/^##\s+Phase:\s*/im);
+        const phaseSections = restOfContent.split(/^##\s+Phase:\s+/m);
         if (!metadata.phases) {
             metadata.phases = {};
         }

package/dist/src/first-run/install-state.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitialFirstRunState = createInitialFirstRunState;
+exports.loadFirstRunState = loadFirstRunState;
+exports.saveFirstRunState = saveFirstRunState;
+exports.clearFirstRunState = clearFirstRunState;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const script_sync_utils_1 = require("../cli/utils/script-sync-utils");
+const types_1 = require("./types");
+function getStatePath() {
+    return path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'install-state.json');
+}
+function ensureUserDir() {
+    fs_1.default.mkdirSync((0, script_sync_utils_1.getUserFraimDir)(), { recursive: true });
+}
+function maskInstallKey(key) {
+    const normalized = key.trim();
+    if (normalized.length <= 8) {
+        return '<redacted>';
+    }
+    return `${normalized.slice(0, 4)}...${normalized.slice(-4)}`;
+}
+function createInitialFirstRunState(key) {
+    const now = new Date().toISOString();
+    return {
+        version: 1,
+        installKeyRef: maskInstallKey(key),
+        platform: process.platform,
+        detectedAgents: [],
+        configuredAgents: [],
+        restartDeferredAgents: [],
+        resourcesUrl: types_1.FIRST_RUN_RESOURCES_URL,
+        stepStates: (0, types_1.createDefaultStepStates)(),
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+function loadFirstRunState() {
+    const statePath = getStatePath();
+    if (!fs_1.default.existsSync(statePath)) {
+        return null;
+    }
+    try {
+        const state = JSON.parse(fs_1.default.readFileSync(statePath, 'utf8'));
+        if (typeof state.installKeyRef === 'string' && !state.installKeyRef.includes('...')) {
+            state.installKeyRef = maskInstallKey(state.installKeyRef);
+        }
+        return state;
+    }
+    catch {
+        return null;
+    }
+}
+function saveFirstRunState(state) {
+    ensureUserDir();
+    state.updatedAt = new Date().toISOString();
+    fs_1.default.writeFileSync(getStatePath(), JSON.stringify(state, null, 2));
+}
+function clearFirstRunState() {
+    const statePath = getStatePath();
+    if (fs_1.default.existsSync(statePath)) {
+        fs_1.default.unlinkSync(statePath);
+    }
+}

package/dist/src/first-run/server.js

@@ -0,0 +1,153 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirstRunServer = void 0;
+const express_1 = __importDefault(require("express"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+function resolveFirstRunPublicDir() {
+    const candidates = [
+        path_1.default.resolve(process.cwd(), 'public/first-run'),
+        path_1.default.resolve(__dirname, '..', '..', 'public/first-run'),
+        path_1.default.resolve(__dirname, '..', '..', '..', 'public/first-run'),
+    ];
+    for (const candidate of candidates) {
+        if (fs_1.default.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error('Could not locate public/first-run assets.');
+}
+function pickProjectPath() {
+    if (process.platform === 'win32') {
+        const script = [
+            'Add-Type -AssemblyName System.Windows.Forms',
+            '$dialog = New-Object System.Windows.Forms.FolderBrowserDialog',
+            '$dialog.ShowNewFolderButton = $true',
+            'if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {',
+            '  Write-Output $dialog.SelectedPath',
+            '}',
+        ].join('; ');
+        const result = (0, child_process_1.spawnSync)('powershell', ['-NoProfile', '-Command', script], {
+            encoding: 'utf8',
+        });
+        return result.status === 0 ? result.stdout.trim() || null : null;
+    }
+    if (process.platform === 'darwin') {
+        const result = (0, child_process_1.spawnSync)('osascript', ['-e', 'POSIX path of (choose folder with prompt "Select a FRAIM project folder")'], {
+            encoding: 'utf8',
+        });
+        return result.status === 0 ? result.stdout.trim() || null : null;
+    }
+    const result = (0, child_process_1.spawnSync)('bash', ['-lc', 'zenity --file-selection --directory 2>/dev/null || kdialog --getexistingdirectory 2>/dev/null'], {
+        encoding: 'utf8',
+    });
+    return result.status === 0 ? result.stdout.trim() || null : null;
+}
+class FirstRunServer {
+    constructor(options) {
+        this.app = (0, express_1.default)();
+        this.sessionService = options.sessionService;
+        this.finishPromise = new Promise((resolve) => {
+            this.finishResolver = resolve;
+        });
+        this.app.use(express_1.default.json());
+        this.app.use('/api/first-run', (req, res, next) => {
+            if (req.method === 'GET') {
+                return next();
+            }
+            const requestToken = req.header('x-fraim-first-run-token');
+            if (requestToken !== this.sessionService.getRequestToken()) {
+                return res.status(403).json({ error: 'Invalid first-run session token.' });
+            }
+            return next();
+        });
+        this.app.use('/first-run', express_1.default.static(resolveFirstRunPublicDir()));
+        this.app.get('/health', (_req, res) => {
+            res.json({ status: 'ok', service: 'fraim-first-run' });
+        });
+        this.registerRoutes();
+    }
+    async start(port) {
+        await new Promise((resolve, reject) => {
+            this.httpServer = this.app.listen(port, '127.0.0.1');
+            this.httpServer.once('listening', () => resolve());
+            this.httpServer.once('error', (error) => reject(error));
+        });
+    }
+    async waitForFinish() {
+        await this.finishPromise;
+    }
+    async stop() {
+        if (!this.httpServer) {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            this.httpServer.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            });
+        });
+        this.httpServer = undefined;
+    }
+    registerRoutes() {
+        this.app.get('/api/first-run/session', (_req, res) => {
+            res.json(this.sessionService.getSession());
+        });
+        this.app.post('/api/first-run/prereqs', (_req, res) => {
+            res.json(this.sessionService.runPrereqChecks());
+        });
+        this.app.post('/api/first-run/agents/select', (req, res) => {
+            if (!req.body.agentId) {
+                return res.status(400).json({ error: 'agentId is required.' });
+            }
+            return res.json(this.sessionService.selectAgent(req.body.agentId));
+        });
+        this.app.post('/api/first-run/configure', async (_req, res) => {
+            try {
+                return res.json(await this.sessionService.configureFraim());
+            }
+            catch (error) {
+                return res.status(500).json({ error: error instanceof Error ? error.message : 'Could not configure FRAIM.' });
+            }
+        });
+        this.app.post('/api/first-run/project-path/pick', (_req, res) => {
+            try {
+                const selectedPath = pickProjectPath();
+                if (!selectedPath) {
+                    return res.status(204).end();
+                }
+                return res.json({ path: selectedPath });
+            }
+            catch (error) {
+                return res.status(500).json({ error: error instanceof Error ? error.message : 'Could not open the folder picker.' });
+            }
+        });
+        this.app.post('/api/first-run/project', async (req, res) => {
+            if (!req.body.projectPath) {
+                return res.status(400).json({ error: 'projectPath is required.' });
+            }
+            try {
+                return res.json(await this.sessionService.initializeProject(req.body.projectPath, req.body.initializeGit !== false));
+            }
+            catch (error) {
+                return res.status(500).json({ error: error instanceof Error ? error.message : 'Could not initialize the project.' });
+            }
+        });
+        this.app.post('/api/first-run/launch', (_req, res) => {
+            return res.json(this.sessionService.launchAndProbe());
+        });
+        this.app.post('/api/first-run/finish', (_req, res) => {
+            const result = this.sessionService.finish();
+            this.finishResolver?.();
+            return res.json(result);
+        });
+    }
+}
+exports.FirstRunServer = FirstRunServer;

package/dist/src/first-run/session-service.js

@@ -0,0 +1,302 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FirstRunSessionService = void 0;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const child_process_1 = require("child_process");
+const ide_detector_1 = require("../cli/setup/ide-detector");
+const auto_mcp_setup_1 = require("../cli/setup/auto-mcp-setup");
+const setup_1 = require("../cli/commands/setup");
+const init_project_1 = require("../cli/commands/init-project");
+const script_sync_utils_1 = require("../cli/utils/script-sync-utils");
+const types_1 = require("./types");
+const install_state_1 = require("./install-state");
+function commandExists(command) {
+    const executable = process.platform === 'win32' ? 'cmd.exe' : command;
+    const args = process.platform === 'win32'
+        ? ['/d', '/s', '/c', `${command} --version`]
+        : ['--version'];
+    const result = (0, child_process_1.spawnSync)(executable, args, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'ignore', 'ignore'],
+        shell: false,
+    });
+    return result.status === 0;
+}
+function ensureOutputDirs() {
+    fs_1.default.mkdirSync((0, script_sync_utils_1.getUserFraimDir)(), { recursive: true });
+    fs_1.default.mkdirSync(path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'last-install'), { recursive: true });
+}
+function getNextPromptPath() {
+    return path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'last-install', 'next-prompt.txt');
+}
+function getInstallLogPath() {
+    return path_1.default.join((0, script_sync_utils_1.getUserFraimDir)(), 'install-log.txt');
+}
+function appendInstallLog(line) {
+    ensureOutputDirs();
+    fs_1.default.appendFileSync(getInstallLogPath(), `[${new Date().toISOString()}] ${line}${os_1.default.EOL}`);
+}
+function getLaunchInstruction(agentId, projectRoot) {
+    const cwd = projectRoot || process.cwd();
+    switch (agentId) {
+        case 'claude-code':
+            return `cd "${cwd}" && claude`;
+        case 'codex':
+            return `cd "${cwd}" && codex`;
+        case 'gemini-cli':
+            return `cd "${cwd}" && gemini`;
+        default:
+            return `cd "${cwd}"`;
+    }
+}
+function maybeLaunchInteractiveShell(agentId, projectRoot) {
+    const commandLine = getLaunchInstruction(agentId, projectRoot);
+    try {
+        if (process.platform === 'win32') {
+            (0, child_process_1.spawn)('cmd.exe', ['/d', '/s', '/c', `start "" cmd /k ${commandLine}`], {
+                detached: true,
+                stdio: 'ignore',
+            }).unref();
+            return true;
+        }
+        if (process.platform === 'darwin') {
+            (0, child_process_1.spawn)('open', ['-a', 'Terminal', projectRoot], {
+                detached: true,
+                stdio: 'ignore',
+            }).unref();
+            return true;
+        }
+        (0, child_process_1.spawn)('x-terminal-emulator', ['-e', 'bash', '-lc', commandLine], {
+            detached: true,
+            stdio: 'ignore',
+        }).unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function probeCodex(projectRoot) {
+    const result = (0, child_process_1.spawnSync)('codex', ['exec', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox'], {
+        cwd: projectRoot,
+        input: 'Reply exactly "FRAIM_READY" if FRAIM is available in this workspace. Otherwise reply exactly "NOT_READY".',
+        encoding: 'utf8',
+        timeout: 60000,
+    });
+    const output = `${result.stdout || ''}${result.stderr || ''}`.trim();
+    return { ok: result.status === 0 && output.toUpperCase().includes('FRAIM'), output };
+}
+function probeClaude(projectRoot) {
+    const result = (0, child_process_1.spawnSync)('claude', ['-p', '--verbose', '--output-format', 'stream-json', '--dangerously-skip-permissions'], {
+        cwd: projectRoot,
+        input: 'Reply exactly "FRAIM_READY" if FRAIM is available in this workspace. Otherwise reply exactly "NOT_READY".',
+        encoding: 'utf8',
+        timeout: 60000,
+    });
+    const output = `${result.stdout || ''}${result.stderr || ''}`.trim();
+    return { ok: result.status === 0 && output.toUpperCase().includes('FRAIM'), output };
+}
+function probeGemini(projectRoot) {
+    const result = (0, child_process_1.spawnSync)('gemini', ['--help'], {
+        cwd: projectRoot,
+        encoding: 'utf8',
+        timeout: 30000,
+    });
+    const output = `${result.stdout || ''}${result.stderr || ''}`.trim();
+    return {
+        ok: result.status === 0,
+        output: output || 'Gemini CLI responded to --help; runtime FRAIM probe still requires manual confirmation.',
+    };
+}
+class FirstRunSessionService {
+    constructor(options) {
+        this.key = options.key;
+        this.headless = options.headless === true;
+        this.fakeMode = process.env.FRAIM_FIRST_RUN_FAKE === '1';
+        this.requestToken = crypto_1.default.randomUUID();
+        this.state = options.resume ? (0, install_state_1.loadFirstRunState)() || (0, install_state_1.createInitialFirstRunState)(options.key) : (0, install_state_1.createInitialFirstRunState)(options.key);
+        if (options.projectRoot) {
+            this.state.workspacePath = path_1.default.resolve(options.projectRoot);
+            this.state.stepStates.project = 'running';
+            (0, install_state_1.saveFirstRunState)(this.state);
+        }
+    }
+    persist() {
+        (0, install_state_1.saveFirstRunState)(this.state);
+    }
+    markStep(step, status) {
+        this.state.stepStates[step] = status;
+        this.persist();
+    }
+    detectAgents() {
+        if (this.fakeMode) {
+            return types_1.FIRST_RUN_AGENT_OPTIONS.map((agent) => ({
+                id: agent.id,
+                label: agent.label,
+                detected: true,
+                detail: 'Fake test-mode agent available.',
+            }));
+        }
+        const detected = (0, ide_detector_1.detectInstalledIDEs)();
+        return types_1.FIRST_RUN_AGENT_OPTIONS.map((agent) => {
+            const ide = detected.find((entry) => entry.aliases?.some((alias) => agent.detectAliases.includes(alias)) ||
+                agent.detectAliases.some((alias) => entry.name.toLowerCase().includes(alias)));
+            return {
+                id: agent.id,
+                label: agent.label,
+                detected: Boolean(ide) || commandExists(agent.launchCommand),
+                detail: ide ? `Config path: ${ide.configPath}` : 'CLI/config not detected yet.',
+            };
+        });
+    }
+    getRequestToken() {
+        return this.requestToken;
+    }
+    getSession() {
+        const agents = this.detectAgents();
+        this.state.detectedAgents = agents.filter((agent) => agent.detected).map((agent) => agent.id);
+        this.persist();
+        return {
+            state: this.state,
+            agents,
+            prompt: types_1.FIRST_RUN_PROMPT,
+            headless: this.headless,
+            requestToken: this.requestToken,
+        };
+    }
+    runPrereqChecks() {
+        this.markStep('prereqs', 'running');
+        const checks = [
+            { label: 'node', ok: commandExists('node') },
+            { label: 'npx', ok: commandExists('npx') },
+            { label: 'git', ok: commandExists('git') },
+        ];
+        const failures = checks.filter((check) => !check.ok).map((check) => check.label);
+        const message = failures.length === 0
+            ? 'Node.js, npx, and git are available.'
+            : `Missing prerequisites: ${failures.join(', ')}.`;
+        appendInstallLog(`prereq-check ${message}`);
+        this.markStep('prereqs', failures.length === 0 ? 'complete' : 'failed');
+        if (failures.length === 0) {
+            this.markStep('agent', 'running');
+        }
+        return { ok: failures.length === 0, message, state: this.state };
+    }
+    selectAgent(agentId) {
+        this.state.selectedAgentId = agentId;
+        this.markStep('agent', 'complete');
+        this.markStep('configure', 'running');
+        appendInstallLog(`agent-selected ${agentId}`);
+        return {
+            ok: true,
+            message: `Selected ${types_1.FIRST_RUN_AGENT_OPTIONS.find((agent) => agent.id === agentId)?.label || agentId}.`,
+            state: this.state,
+            launchCommand: types_1.FIRST_RUN_AGENT_OPTIONS.find((agent) => agent.id === agentId)?.loginCommand,
+        };
+    }
+    async configureFraim() {
+        this.markStep('configure', 'running');
+        (0, setup_1.saveGlobalConfig)(this.key, 'conversational', {}, {});
+        if (!this.fakeMode) {
+            const selectedAgent = this.state.selectedAgentId ? (0, ide_detector_1.findIDEByName)(this.state.selectedAgentId) : undefined;
+            const targetNames = selectedAgent ? [selectedAgent.name] : undefined;
+            await (0, auto_mcp_setup_1.autoConfigureMCP)(this.key, {}, targetNames, {});
+            this.state.configuredAgents = this.detectAgents().filter((agent) => agent.detected).map((agent) => agent.id);
+        }
+        else {
+            this.state.configuredAgents = this.state.selectedAgentId ? [this.state.selectedAgentId] : [];
+        }
+        appendInstallLog(`configure configuredAgents=${this.state.configuredAgents.join(',')}`);
+        this.markStep('configure', 'complete');
+        this.markStep('project', 'running');
+        return {
+            ok: true,
+            message: 'Saved FRAIM global configuration and wrote agent config where available.',
+            state: this.state,
+        };
+    }
+    async initializeProject(projectPath, initializeGit = true) {
+        const resolvedPath = path_1.default.resolve(projectPath);
+        fs_1.default.mkdirSync(resolvedPath, { recursive: true });
+        this.markStep('project', 'running');
+        if (initializeGit && commandExists('git')) {
+            try {
+                (0, child_process_1.execSync)('git rev-parse --git-dir', { cwd: resolvedPath, stdio: 'ignore' });
+            }
+            catch {
+                (0, child_process_1.execSync)('git init', { cwd: resolvedPath, stdio: 'ignore' });
+            }
+        }
+        await (0, init_project_1.runInitProject)({ projectRoot: resolvedPath });
+        this.state.workspacePath = resolvedPath;
+        this.markStep('project', 'complete');
+        this.markStep('launch', 'running');
+        appendInstallLog(`project-initialized ${resolvedPath}`);
+        return {
+            ok: true,
+            message: `Initialized FRAIM in ${resolvedPath}.`,
+            state: this.state,
+        };
+    }
+    launchAndProbe() {
+        const agentId = this.state.selectedAgentId;
+        const projectRoot = this.state.workspacePath;
+        if (!agentId || !projectRoot) {
+            this.markStep('launch', 'failed');
+            return {
+                ok: false,
+                message: 'Select an agent and project folder before launch.',
+                state: this.state,
+            };
+        }
+        const launchCommand = getLaunchInstruction(agentId, projectRoot);
+        const opened = this.fakeMode ? true : maybeLaunchInteractiveShell(agentId, projectRoot);
+        let probeResult = { ok: true, output: 'Fake test-mode launch succeeded.' };
+        if (!this.fakeMode) {
+            if (agentId === 'codex') {
+                probeResult = probeCodex(projectRoot);
+            }
+            else if (agentId === 'claude-code') {
+                probeResult = probeClaude(projectRoot);
+            }
+            else {
+                probeResult = probeGemini(projectRoot);
+            }
+        }
+        this.state.lastLaunchCommand = launchCommand;
+        this.state.lastProbeMessage = probeResult.output;
+        this.markStep('launch', probeResult.ok ? 'complete' : 'failed');
+        if (probeResult.ok) {
+            this.markStep('finish', 'running');
+        }
+        appendInstallLog(`launch agent=${agentId} opened=${opened} probeOk=${probeResult.ok}`);
+        return {
+            ok: probeResult.ok,
+            message: opened
+                ? 'Agent launch was attempted and the probe completed.'
+                : 'Agent launch could not be opened automatically; use the provided command and review the probe output.',
+            state: this.state,
+            launchCommand,
+            output: probeResult.output,
+        };
+    }
+    finish() {
+        ensureOutputDirs();
+        fs_1.default.writeFileSync(getNextPromptPath(), `${types_1.FIRST_RUN_PROMPT}${os_1.default.EOL}`, 'utf8');
+        this.state.nextPrompt = types_1.FIRST_RUN_PROMPT;
+        this.markStep('finish', 'complete');
+        appendInstallLog('finish prompt-written');
+        return {
+            ok: true,
+            message: 'Wrote the next prompt artifact and completed first-run.',
+            state: this.state,
+        };
+    }
+}
+exports.FirstRunSessionService = FirstRunSessionService;

package/dist/src/first-run/types.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIRST_RUN_AGENT_OPTIONS = exports.FIRST_RUN_RESOURCES_URL = exports.FIRST_RUN_PROMPT = void 0;
+exports.createDefaultStepStates = createDefaultStepStates;
+exports.FIRST_RUN_PROMPT = 'Onboard this project';
+exports.FIRST_RUN_RESOURCES_URL = 'https://fraimworks.ai/resources.html';
+exports.FIRST_RUN_AGENT_OPTIONS = [
+    {
+        id: 'claude-code',
+        label: 'Claude Code',
+        detectAliases: ['claude-code', 'claude code', 'claude'],
+        loginCommand: 'claude',
+        launchCommand: 'claude',
+    },
+    {
+        id: 'codex',
+        label: 'Codex',
+        detectAliases: ['codex'],
+        loginCommand: 'codex login',
+        launchCommand: 'codex',
+    },
+    {
+        id: 'gemini-cli',
+        label: 'Gemini CLI',
+        detectAliases: ['gemini-cli', 'gemini cli', 'gemini'],
+        loginCommand: 'gemini',
+        launchCommand: 'gemini',
+    },
+];
+function createDefaultStepStates() {
+    return {
+        welcome: 'pending',
+        prereqs: 'pending',
+        agent: 'pending',
+        configure: 'pending',
+        project: 'pending',
+        launch: 'pending',
+        finish: 'pending',
+    };
+}