vigthoria-cli 1.13.26 → 1.13.30

package/dist/commands/fork.js

@@ -3,14 +3,17 @@ import { hasLocalV3AgentCapability } from '../utils/runtime-capability.js';
  * fork.ts — Fork from an existing V3 agent run and stream the result.
  */
 import chalk from 'chalk';
-import { createRequire } from 'node:module';
 import { createSpinner, CH } from '../utils/logger.js';
 import { CliCommandError, commandFailure, formatSuccessJson } from '../utils/command-contract.js';
-const require = createRequire(import.meta.url);
+import { createAPIClient } from '../utils/api-client-factory.js';
+import { buildLocalWorkspaceReference } from '../utils/workspace-reference.js';
+import { guardedFetch } from '../utils/network-policy.js';
 export class ForkCommand {
     config;
-    constructor(config, _logger) {
+    logger;
+    constructor(config, logger) {
         this.config = config;
+        this.logger = logger;
     }
     getHeaders() {
         const headers = { 'Content-Type': 'application/json' };
@@ -34,50 +37,69 @@ export class ForkCommand {
             (allowLocal ? 'http://127.0.0.1:8030' : null) ||
             configuredApiUrl);
     }
-    resolveWorkspaceRoot(project) {
-        if (/^[a-zA-Z]:[\\/]/.test(project) || /^\\\\/.test(project))
-            return '';
-        if (typeof require !== 'undefined') {
-            try {
-                const path = require('path');
-                if (!path.isAbsolute(project))
-                    return '';
+    buildForkHistory(events, eventIndex) {
+        const selected = eventIndex > 0 ? events.slice(0, eventIndex) : events;
+        const lines = [
+            `Fork point: ${eventIndex > 0 ? eventIndex : events.length} of ${events.length} recorded events.`,
+            'Prior run evidence (metadata only; re-read current files through client tools):',
+        ];
+        let toolCalls = 0;
+        for (const event of selected.slice(-120)) {
+            const type = String(event?.type || 'unknown');
+            if (type === 'plan') {
+                const count = Array.isArray(event.tasks) ? event.tasks.length : 0;
+                lines.push(`- plan: ${count} task(s)`);
             }
-            catch { }
+            else if (type === 'tool_call') {
+                toolCalls += 1;
+                lines.push(`- tool_call ${toolCalls}: ${String(event.name || 'unknown').slice(0, 80)}`);
+            }
+            else if (type === 'tool_result') {
+                lines.push(`- tool_result: ${String(event.name || 'unknown').slice(0, 80)} success=${event.success !== false}`);
+            }
+            else if (type === 'file_mutation') {
+                lines.push(`- file_mutation: ${String(event.kind || 'change').slice(0, 32)} (path intentionally omitted)`);
+            }
+            else if (type === 'complete') {
+                lines.push('- prior run reached its completion event');
+            }
+            else if (type === 'error') {
+                lines.push(`- prior run error code: ${String(event.code || event.error_code || 'unspecified').slice(0, 80)}`);
+            }
+            if (lines.join('\n').length > 12_000)
+                break;
         }
-        return project;
+        return lines.join('\n').slice(0, 12_000);
     }
     async run(runId, message, options) {
         const project = options.project || process.cwd();
-        const workspace = this.resolveWorkspaceRoot(project);
+        const workspaceRef = buildLocalWorkspaceReference(project, String(this.config.get('userId') || this.config.get('email') || ''));
         const eventIndex = options.eventIndex || 0;
-        const spinner = createSpinner(`Forking run ${runId}...`).start();
+        const spinner = createSpinner(`Loading run ${runId} for a local fork...`).start();
         const streamController = new AbortController();
+        let api = null;
         let interrupted = false;
         const onInterrupt = () => {
             interrupted = true;
             streamController.abort();
+            api?.destroy();
         };
         process.once('SIGINT', onInterrupt);
         try {
             const baseUrl = this.getBaseUrl();
-            const body = {
-                workspace_root: workspace,
-                from_event_index: eventIndex,
-                new_request: message || '',
-                stream: true,
-                context: '',
-            };
-            const resp = await fetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/fork`, {
-                method: 'POST',
+            const params = new URLSearchParams({
+                workspace_root: '',
+                local_workspace_path: workspaceRef,
+                project_path: workspaceRef,
+            });
+            const resp = await guardedFetch(`${baseUrl}/api/runs/${encodeURIComponent(runId)}/events?${params}`, {
                 headers: this.getHeaders(),
-                body: JSON.stringify(body),
                 signal: streamController.signal,
-            });
+            }, { audience: 'v3' });
             if (!resp.ok) {
                 spinner.stop();
                 if (resp.status === 404) {
-                    throw new CliCommandError(`Run ${runId} not found or has no event log.`, {
+                    throw new CliCommandError(`Run ${runId} was not found or has no event log.`, {
                         code: 'RUN_NOT_FOUND', status: resp.status,
                     });
                 }
@@ -87,116 +109,94 @@ export class ForkCommand {
                     });
                 }
                 else {
-                    throw new CliCommandError(`Fork failed: ${resp.status} ${resp.statusText}`, {
+                    throw new CliCommandError(`Could not load the fork source: ${resp.status} ${resp.statusText}`, {
                         code: 'RUN_FORK_FAILED', status: resp.status,
                     });
                 }
             }
+            const source = (await resp.json());
+            const sourceEvents = Array.isArray(source.events) ? source.events : [];
+            if (eventIndex < 0 || eventIndex > sourceEvents.length) {
+                throw new CliCommandError(`Fork event index ${eventIndex} is outside 0..${sourceEvents.length}.`, {
+                    code: 'RUN_FORK_EVENT_INDEX_INVALID',
+                });
+            }
+            const forkHistory = this.buildForkHistory(sourceEvents, eventIndex);
             spinner.stop();
-            if (!options.json)
-                console.log(chalk.bold(`\n${CH.success} Forked from ${chalk.cyan(runId)} at event ${eventIndex}\n`));
-            if (!resp.body) {
-                throw new CliCommandError('Fork response did not contain an event stream', { code: 'RUN_FORK_STREAM_MISSING' });
+            if (!options.json) {
+                console.log(chalk.bold(`\n${CH.success} Starting local fork from ${chalk.cyan(runId)} at event ${eventIndex || sourceEvents.length}\n`));
             }
-            // Stream SSE events
-            const reader = resp.body.getReader();
-            const decoder = new TextDecoder();
-            let buffer = '';
+            const streamEvents = [];
             let toolCallNum = 0;
-            let completed = false;
-            const events = [];
-            const configuredIdle = Number.parseInt(process.env.VIGTHORIA_FORK_IDLE_TIMEOUT_MS || '', 10);
-            const idleTimeoutMs = Number.isFinite(configuredIdle) && configuredIdle > 0 ? configuredIdle : 60_000;
-            stream: while (true) {
-                let timer;
-                const { done, value } = await Promise.race([
-                    reader.read(),
-                    new Promise((_resolve, reject) => {
-                        timer = setTimeout(() => {
-                            streamController.abort();
-                            reject(new CliCommandError(`Fork event stream was idle for ${idleTimeoutMs}ms.`, {
-                                code: 'RUN_FORK_IDLE_TIMEOUT', category: 'network',
-                            }));
-                        }, idleTimeoutMs);
-                    }),
-                ]).finally(() => {
-                    if (timer)
-                        clearTimeout(timer);
-                });
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    if (!line.startsWith('data: '))
-                        continue;
-                    const payload = line.slice(6).trim();
-                    if (payload === '[DONE]') {
-                        completed = true;
-                        break stream;
+            api = createAPIClient(this.config, this.logger);
+            const request = [
+                message.trim() || 'Continue the previous run from the selected fork point.',
+                '',
+                forkHistory,
+                '',
+                'Use the current client-authoritative workspace as truth. Re-read every needed file through client tools; do not assume prior file contents.',
+            ].join('\n');
+            const result = await api.runV3AgentWorkflow(request, {
+                projectPath: project,
+                targetPath: project,
+                workspacePath: project,
+                localWorkspacePath: project,
+                localMachineCapable: true,
+                clientToolExecution: true,
+                executionSurface: 'fork',
+                clientSurface: 'cli',
+                rawPrompt: message || request,
+                contextualPrompt: forkHistory,
+                forkedFrom: runId,
+                forkEventIndex: eventIndex,
+                onStreamEvent: (event) => {
+                    streamEvents.push({
+                        type: String(event.type || 'unknown'),
+                        name: typeof event.name === 'string' ? event.name : undefined,
+                        success: typeof event.success === 'boolean' ? event.success : undefined,
+                        code: typeof event.code === 'string' ? event.code : undefined,
+                    });
+                    if (options.json)
+                        return;
+                    const type = String(event.type || 'unknown');
+                    if (type === 'plan') {
+                        console.log(chalk.magenta(`  📋 PLAN`) + ` ${event.tasks?.length || 0} tasks`);
                     }
-                    try {
-                        const evt = JSON.parse(payload);
-                        const type = evt.type || 'unknown';
-                        events.push(evt);
-                        if (options.json) {
-                            continue;
-                        }
-                        switch (type) {
-                            case 'context':
-                                console.log(chalk.blue(`  context: ${evt.context_id || '?'}`) +
-                                    (evt.forked_from ? chalk.dim(` (forked from ${evt.forked_from})`) : ''));
-                                break;
-                            case 'start':
-                                console.log(chalk.green(`  ▶ START`) + ` task=${evt.task_id || '?'}` +
-                                    (evt.forked_from ? chalk.dim(` forked_from=${evt.forked_from}`) : ''));
-                                break;
-                            case 'plan':
-                                console.log(chalk.magenta(`  📋 PLAN`) + ` ${evt.tasks?.length || 0} tasks`);
-                                break;
-                            case 'tool_call':
-                                toolCallNum++;
-                                console.log(chalk.yellow(`  🔧 #${toolCallNum}`) + ` ${evt.name || '?'}(${JSON.stringify(evt.arguments || {}).substring(0, 60)})`);
-                                break;
-                            case 'tool_result': {
-                                const icon = evt.success !== false ? chalk.green('✓') : chalk.red('✗');
-                                console.log(`    ${icon} ${evt.name || '?'}: ${chalk.dim((evt.output || '').substring(0, 100))}`);
-                                break;
-                            }
-                            case 'message':
-                                console.log(chalk.cyan(`  💬 `) + (evt.content || '').substring(0, 150));
-                                break;
-                            case 'complete': {
-                                const seal = evt.seal_score ? `[${evt.seal_score.tier} ${evt.seal_score.overall}]` : '';
-                                console.log(chalk.green(`  ✅ COMPLETE `) + chalk.yellow(seal) +
-                                    ` ${evt.iterations || '?'} iterations, ${evt.tool_calls || '?'} tool calls`);
-                                break;
-                            }
-                            case 'error':
-                                throw new CliCommandError(String(evt.message || 'Fork stream reported an error.'), {
-                                    code: 'RUN_FORK_STREAM_ERROR', details: evt,
-                                });
-                            default:
-                                console.log(chalk.dim(`  ${type}: ${JSON.stringify(evt).substring(0, 80)}`));
-                        }
+                    else if (type === 'tool_call') {
+                        toolCallNum += 1;
+                        console.log(chalk.yellow(`  🔧 #${toolCallNum}`) + ` ${event.name || '?'}`);
                     }
-                    catch (error) {
-                        if (error instanceof CliCommandError)
-                            throw error;
-                        throw new CliCommandError('Fork event stream contained malformed JSON.', {
-                            code: 'RUN_FORK_STREAM_MALFORMED', details: { payload: payload.slice(0, 200) }, cause: error,
-                        });
+                    else if (type === 'tool_result') {
+                        const icon = event.success !== false ? chalk.green('✓') : chalk.red('✗');
+                        console.log(`    ${icon} ${event.name || '?'}`);
                     }
-                }
-            }
-            if (!completed) {
-                throw new CliCommandError('Fork event stream ended without a completion marker.', { code: 'RUN_FORK_STREAM_INCOMPLETE' });
+                    else if (type === 'message' && event.content) {
+                        console.log(chalk.cyan('  💬 ') + String(event.content).slice(0, 180));
+                    }
+                    else if (type === 'complete') {
+                        console.log(chalk.green('  ✅ COMPLETE'));
+                    }
+                },
+            });
+            if (result.partial) {
+                throw new CliCommandError('Fork execution ended with a partial result.', {
+                    code: 'RUN_FORK_PARTIAL', details: { contextId: result.contextId, taskId: result.taskId },
+                });
             }
             if (options.json) {
-                console.log(formatSuccessJson('fork', { runId, eventIndex, events }, { stream: true, eventCount: events.length }));
+                console.log(formatSuccessJson('fork', {
+                    runId,
+                    eventIndex: eventIndex || sourceEvents.length,
+                    taskId: result.taskId,
+                    contextId: result.contextId,
+                    content: result.content,
+                    changedFiles: Object.keys(result.changedFiles || {}),
+                    events: streamEvents,
+                }, { stream: true, eventCount: streamEvents.length, workspaceAuthority: 'client-tool-bridge' }));
             }
             else {
+                if (result.content)
+                    console.log(result.content);
                 console.log(chalk.bold(`\n${CH.success} Fork run complete\n`));
             }
         }
@@ -208,6 +208,7 @@ export class ForkCommand {
             throw commandFailure(err, { code: 'RUN_FORK_FAILED' });
         }
         finally {
+            api?.destroy();
             process.removeListener('SIGINT', onInterrupt);
         }
     }

package/dist/commands/game.d.ts

@@ -8,6 +8,14 @@ export declare function gameProcessInvocation(pm: Manager, args: readonly string
     executable: string;
     args: string[];
 };
+export declare function windowsProcessTreeTerminationInvocation(pid: number, systemRoot?: string): {
+    executable: string;
+    args: string[];
+};
+export declare const runGameProcess: (pm: Manager, args: string[], cwd: string, timeoutMs?: number, outputMode?: "inherit" | "capture") => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
 export declare class GameCommand {
     private logger;
     constructor(logger: Logger);

package/dist/commands/game.js

@@ -46,11 +46,114 @@ export function gameProcessInvocation(pm, args, platform = process.platform, com
     const command = [executable, ...args].join(' ');
     return { executable: comSpec, args: ['/d', '/s', '/c', command] };
 }
-const run = (pm, args, cwd, timeoutMs = 10 * 60_000) => new Promise((resolve, reject) => { const invocation = gameProcessInvocation(pm, args); const child = spawn(invocation.executable, invocation.args, { cwd, stdio: 'inherit', windowsHide: true, env: safeChildProcessEnv() }); let interrupted = false; const onInterrupt = () => { interrupted = true; child.kill('SIGINT'); }; process.once('SIGINT', onInterrupt); const timer = timeoutMs > 0 ? setTimeout(() => { child.kill('SIGTERM'); reject(new CliCommandError(`${pm} command timed out after ${timeoutMs}ms`, { code: 'GAME_PROCESS_TIMEOUT' })); }, timeoutMs) : null; const finish = () => { if (timer)
-    clearTimeout(timer); process.removeListener('SIGINT', onInterrupt); }; child.once('error', error => { finish(); reject(error); }); child.once('exit', (code, signal) => { finish(); if (interrupted)
-    reject(new CliCommandError(`${pm} command cancelled by user`, { code: 'GAME_PROCESS_CANCELLED', category: 'cancelled' }));
-else
-    code === 0 ? resolve() : reject(new Error(`${pm} exited with ${signal || code}`)); }); });
+export function windowsProcessTreeTerminationInvocation(pid, systemRoot = process.env.SystemRoot || 'C:\\Windows') {
+    if (!Number.isSafeInteger(pid) || pid <= 0) {
+        throw new CliCommandError('Cannot terminate a game process without a valid owned PID.', {
+            code: 'GAME_PROCESS_ID_INVALID',
+        });
+    }
+    return {
+        executable: path.win32.join(systemRoot, 'System32', 'taskkill.exe'),
+        args: ['/PID', String(pid), '/T', '/F'],
+    };
+}
+async function terminateOwnedProcessTree(child, platform) {
+    const pid = child.pid;
+    if (!pid)
+        return;
+    if (platform === 'win32') {
+        const invocation = windowsProcessTreeTerminationInvocation(pid);
+        await new Promise((resolve) => {
+            const killer = spawn(invocation.executable, invocation.args, {
+                stdio: 'ignore',
+                windowsHide: true,
+                env: safeChildProcessEnv(),
+            });
+            const timer = setTimeout(() => { try {
+                killer.kill();
+            }
+            catch { /* exact helper only */ } resolve(); }, 5_000);
+            killer.once('error', () => { clearTimeout(timer); try {
+                child.kill();
+            }
+            catch { /* already gone */ } resolve(); });
+            killer.once('exit', () => { clearTimeout(timer); resolve(); });
+        });
+        return;
+    }
+    try {
+        process.kill(-pid, 'SIGTERM');
+    }
+    catch {
+        try {
+            child.kill('SIGTERM');
+        }
+        catch { /* already gone */ }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+    try {
+        process.kill(-pid, 0);
+        process.kill(-pid, 'SIGKILL');
+    }
+    catch { /* process group exited */ }
+}
+export const runGameProcess = (pm, args, cwd, timeoutMs = 10 * 60_000, outputMode = 'inherit') => new Promise((resolve, reject) => {
+    const invocation = gameProcessInvocation(pm, args);
+    const platform = process.platform;
+    const child = spawn(invocation.executable, invocation.args, {
+        cwd,
+        stdio: outputMode === 'capture' ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+        windowsHide: true,
+        env: safeChildProcessEnv(),
+        detached: platform !== 'win32',
+    });
+    let interrupted = false;
+    let timedOut = false;
+    let settled = false;
+    let stdout = '';
+    let stderr = '';
+    const appendBounded = (current, chunk) => `${current}${String(chunk)}`.slice(-64 * 1024);
+    if (outputMode === 'capture') {
+        child.stdout?.setEncoding('utf8');
+        child.stderr?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => { stdout = appendBounded(stdout, chunk); });
+        child.stderr?.on('data', (chunk) => { stderr = appendBounded(stderr, chunk); });
+    }
+    const settle = (error) => {
+        if (settled)
+            return;
+        settled = true;
+        if (timer)
+            clearTimeout(timer);
+        process.removeListener('SIGINT', onInterrupt);
+        error ? reject(error) : resolve({ stdout, stderr });
+    };
+    const onInterrupt = () => {
+        interrupted = true;
+        void terminateOwnedProcessTree(child, platform);
+    };
+    process.once('SIGINT', onInterrupt);
+    const timer = timeoutMs > 0 ? setTimeout(() => {
+        timedOut = true;
+        void terminateOwnedProcessTree(child, platform).finally(() => settle(new CliCommandError(`${pm} command timed out after ${timeoutMs}ms`, { code: 'GAME_PROCESS_TIMEOUT' })));
+    }, timeoutMs) : null;
+    child.once('error', (error) => settle(error));
+    child.once('exit', (code, signal) => {
+        if (timedOut) {
+            settle(new CliCommandError(`${pm} command timed out after ${timeoutMs}ms`, { code: 'GAME_PROCESS_TIMEOUT' }));
+        }
+        else if (interrupted) {
+            settle(new CliCommandError(`${pm} command cancelled by user`, { code: 'GAME_PROCESS_CANCELLED', category: 'cancelled' }));
+        }
+        else if (code === 0) {
+            settle();
+        }
+        else {
+            const detail = outputMode === 'capture' ? `: ${(stderr || stdout).trim().slice(-4_000)}` : '';
+            settle(new Error(`${pm} exited with ${signal || code}${detail}`));
+        }
+    });
+});
 const html = `<!doctype html><html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>VGE Game</title></head><body><canvas id="game"></canvas><div id="hud"><strong>Vigthoria Gaming Engine</strong><span>Ready</span></div><script type="module" src="/src/main.ts"></script></body></html>\n`;
 const style = `*{box-sizing:border-box}html,body,#game{width:100%;height:100%;margin:0;overflow:hidden}body{background:#030510;color:#e8f7ff;font-family:Inter,system-ui,sans-serif}#game{display:block;touch-action:none}#hud{position:fixed;left:24px;top:24px;display:flex;gap:16px;padding:12px 16px;border:1px solid #00d4ff66;border-radius:12px;background:#070a18cc;backdrop-filter:blur(12px);box-shadow:0 0 32px #7c3aed33}#hud span{color:#5eead4}\n`;
 const main = `import { ArcRotateCamera, Color3, Color4, DirectionalLight, Engine, HemisphericLight, MeshBuilder, PBRMaterial, Scene, ShadowGenerator, Vector3 } from '@babylonjs/core';
@@ -80,21 +183,22 @@ export class GameCommand {
         if (fs.existsSync(root) && fs.readdirSync(root).length)
             throw new Error(`Target directory is not empty: ${root}`);
         fs.mkdirSync(path.join(root, 'src'), { recursive: true });
-        const pkg = { name: slug, version: '0.1.0', private: true, type: 'module', vigthoria: { kind: 'game', engine: 'babylon', renderTransport: 'client-state', schemaVersion: 1 }, scripts: { dev: 'vite', build: 'tsc --noEmit && vite build', preview: 'vite preview' }, dependencies: { '@babylonjs/core': '7.54.3', '@babylonjs/loaders': '7.54.3' }, devDependencies: { typescript: '5.8.3', vite: '6.1.0' } };
+        const pkg = { name: slug, version: '0.1.0', private: true, type: 'module', engines: { node: '>=20.19.0' }, vigthoria: { kind: 'game', engine: 'babylon', renderTransport: 'client-state', schemaVersion: 1 }, scripts: { dev: 'node ./node_modules/vite/bin/vite.js', build: 'node ./node_modules/typescript/bin/tsc --noEmit && node ./node_modules/vite/bin/vite.js build', preview: 'node ./node_modules/vite/bin/vite.js preview' }, dependencies: { '@babylonjs/core': '9.20.0', '@babylonjs/loaders': '9.20.0' }, devDependencies: { typescript: '5.9.3', vite: '7.3.6' } };
         fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify(pkg, null, 2) + '\n');
         fs.writeFileSync(path.join(root, 'index.html'), html);
         fs.writeFileSync(path.join(root, 'src/main.ts'), main);
         fs.writeFileSync(path.join(root, 'src/style.css'), style);
+        fs.writeFileSync(path.join(root, 'src/vite-env.d.ts'), '/// <reference types="vite/client" />\n');
         fs.writeFileSync(path.join(root, '.gitignore'), 'node_modules\ndist\n.vigthoria\n');
         fs.writeFileSync(path.join(root, 'tsconfig.json'), JSON.stringify({ compilerOptions: { target: 'ES2022', module: 'ESNext', lib: ['ES2022', 'DOM'], skipLibCheck: true, moduleResolution: 'Bundler', isolatedModules: true, noEmit: true, strict: true }, include: ['src'] }, null, 2) + '\n');
         if (o.install !== false)
-            await run(manager(root, o.packageManager), ['install'], root);
+            await runGameProcess(manager(root, o.packageManager), ['install'], root);
         this.logger.success(`Babylon/VGE game created: ${root}`);
         this.logger.info(`Next: cd ${slug} && vigthoria game run`);
     }
     async run(o) { const root = path.resolve(o.project || process.cwd()); this.project(root); const args = ['run', 'dev', '--', '--host', '127.0.0.1']; if (o.port)
         args.push('--port', String(o.port)); if (o.open !== false)
-        args.push('--open'); await run(manager(root, o.packageManager), args, root, 0); }
+        args.push('--open'); await runGameProcess(manager(root, o.packageManager), args, root, 0); }
     async validate(o) {
         const root = path.resolve(o.project || process.cwd());
         const checks = [];
@@ -110,7 +214,7 @@ export class GameCommand {
         const source = this.sources(root);
         checks.push({ check: 'Babylon client-state metadata', passed: pkg.vigthoria?.engine === 'babylon' && pkg.vigthoria?.renderTransport === 'client-state' }, { check: 'Pinned local Babylon dependencies', passed: /^\d/.test(pkg.dependencies?.['@babylonjs/core'] || '') && /^\d/.test(pkg.dependencies?.['@babylonjs/loaders'] || '') }, { check: 'No CDN engine imports', passed: !/https?:\/\/(cdn|unpkg|jsdelivr)[^\s"']*(babylon|three)/i.test(source) }, { check: 'Runtime diagnostics', passed: source.includes('__vgeDiagnostics') }, { check: 'Client source entry', passed: fs.existsSync(path.join(root, 'src/main.ts')) || fs.existsSync(path.join(root, 'src/main.js')) });
         try {
-            await run(manager(root, o.packageManager), ['run', 'build'], root);
+            await runGameProcess(manager(root, o.packageManager), ['run', 'build'], root, 10 * 60_000, o.json ? 'capture' : 'inherit');
             checks.push({ check: 'Production build', passed: true });
         }
         catch (e) {

package/dist/commands/history.d.ts

@@ -11,7 +11,6 @@ export declare class HistoryCommand {
     constructor(config: Config, logger: Logger);
     private getHeaders;
     private getBaseUrl;
-    private resolveWorkspaceRoot;
     run(options: HistoryOptions): Promise<void>;
 }
 export {};

package/dist/commands/history.js

@@ -3,10 +3,10 @@ import { hasLocalV3AgentCapability } from '../utils/runtime-capability.js';
  * history.ts — List recent V3 agent runs with summaries.
  */
 import chalk from 'chalk';
-import { createRequire } from 'node:module';
 import { createSpinner, CH } from '../utils/logger.js';
 import { CliCommandError, commandFailure, formatSuccessJson } from '../utils/command-contract.js';
-const require = createRequire(import.meta.url);
+import { buildLocalWorkspaceReference } from '../utils/workspace-reference.js';
+import { guardedFetch } from '../utils/network-policy.js';
 export class HistoryCommand {
     config;
     logger;
@@ -36,36 +36,22 @@ export class HistoryCommand {
             (allowLocal ? 'http://127.0.0.1:8030' : null) ||
             configuredApiUrl);
     }
-    resolveWorkspaceRoot(project) {
-        // On Windows or non-absolute paths, send empty so the server uses its fallback root
-        if (/^[a-zA-Z]:[\\/]/.test(project) || /^\\\\/.test(project))
-            return '';
-        if (typeof require !== 'undefined') {
-            try {
-                const path = require('path');
-                if (!path.isAbsolute(project))
-                    return '';
-            }
-            catch { }
-        }
-        return project;
-    }
     async run(options) {
         const limit = options.limit || 20;
         const project = options.project || process.cwd();
-        const workspace = this.resolveWorkspaceRoot(project);
+        const workspaceRef = buildLocalWorkspaceReference(project, String(this.config.get('userId') || this.config.get('email') || ''));
         const spinner = createSpinner('Loading run history...').start();
         try {
             const baseUrl = this.getBaseUrl();
             const params = new URLSearchParams({
                 limit: String(limit),
-                workspace_root: workspace,
-                local_workspace_path: project,
-                project_path: project,
+                workspace_root: '',
+                local_workspace_path: workspaceRef,
+                project_path: workspaceRef,
             });
-            const resp = await fetch(`${baseUrl}/api/runs?${params}`, {
+            const resp = await guardedFetch(`${baseUrl}/api/runs?${params}`, {
                 headers: this.getHeaders(),
-            });
+            }, { audience: 'v3' });
             if (!resp.ok) {
                 spinner.stop();
                 if (resp.status === 404 || resp.status === 502 || resp.status === 503) {

package/dist/commands/hub.d.ts

@@ -6,6 +6,25 @@
  */
 import { Config } from '../utils/config.js';
 import { Logger } from '../utils/logger.js';
+interface Module {
+    id: string;
+    name: string;
+    description: string;
+    endpoint: string;
+    documentation: string;
+    pricing: {
+        unit: string;
+        cost: number;
+        example: string;
+    };
+    status: string;
+    category: string;
+    tags: string[];
+    unit?: string;
+    creditsPerUnit?: number | string;
+    euroPerUnit?: number | string;
+}
+export declare function moduleMatchesIdentifier(module: Pick<Module, 'id' | 'name'>, requested: string): boolean;
 export declare class HubCommand {
     private config;
     constructor(config: Config, _logger: Logger);
@@ -39,3 +58,4 @@ export declare class HubCommand {
      */
     discover(): Promise<void>;
 }
+export {};

package/dist/commands/hub.js

@@ -8,6 +8,19 @@ import chalk from 'chalk';
 import { guardedFetch } from '../utils/network-policy.js';
 import { CliCommandError, commandFailure } from '../utils/command-contract.js';
 const API_BASE = 'https://hub.vigthoria.io';
+function normalizeModuleIdentifier(value) {
+    return String(value || '').trim().toLowerCase().replace(/[\s_]+/g, '-');
+}
+export function moduleMatchesIdentifier(module, requested) {
+    const needle = normalizeModuleIdentifier(requested);
+    if (!needle)
+        return false;
+    const id = normalizeModuleIdentifier(module.id);
+    const name = normalizeModuleIdentifier(module.name);
+    return needle === id
+        || needle === name
+        || needle === id.replace(/-api$/, '');
+}
 export class HubCommand {
     config;
     constructor(config, _logger) {
@@ -76,6 +89,7 @@ export class HubCommand {
             data.results.forEach((module, index) => {
                 const statusColor = module.status === 'available' ? chalk.green : chalk.gray;
                 console.log(chalk.bold.white(`  ${index + 1}. ${module.name}`));
+                console.log(chalk.gray(`     Module ID: ${module.id}`));
                 console.log(chalk.gray(`     ${module.description.substring(0, 80)}...`));
                 console.log(chalk.cyan(`     💰 ${module.pricing.example}`));
                 console.log(statusColor(`     📊 Status: ${module.status.toUpperCase()}`));
@@ -86,7 +100,7 @@ export class HubCommand {
                 console.log(chalk.cyan(`💡 ${data.suggestion}`));
             }
             console.log(chalk.gray('\nTo activate a module: vigthoria hub activate <module-name>'));
-            console.log(chalk.gray('Example: vigthoria hub activate music\n'));
+            console.log(chalk.gray(`Example: vigthoria hub activate ${data.results[0].id}\n`));
         }
         catch (error) {
             throw commandFailure(error, { code: 'HUB_SEARCH_FAILED' });
@@ -144,7 +158,7 @@ export class HubCommand {
         this.getAuthToken();
         console.log(chalk.cyan(`\n🔌 Activating module: ${moduleId}...\n`));
         try {
-            const module = (await this.moduleCatalog()).find((entry) => entry.id === moduleId);
+            const module = (await this.moduleCatalog()).find((entry) => moduleMatchesIdentifier(entry, moduleId));
             if (!module)
                 throw new CliCommandError(`Unknown Hub module: ${moduleId}`, { code: 'HUB_MODULE_NOT_FOUND', category: 'usage' });
             console.log(chalk.green(`✅ ${module.name} is published in the Vigthoria module catalog.`));
@@ -186,7 +200,7 @@ export class HubCommand {
     async info(moduleId) {
         console.log(chalk.cyan(`\n📖 Module Info: ${moduleId}\n`));
         try {
-            const module = (await this.moduleCatalog()).find((entry) => entry.id === moduleId);
+            const module = (await this.moduleCatalog()).find((entry) => moduleMatchesIdentifier(entry, moduleId));
             if (!module)
                 throw new CliCommandError(`Unknown Hub module: ${moduleId}`, { code: 'HUB_MODULE_NOT_FOUND', category: 'usage' });
             console.log(chalk.bold.white(`${module.name}`));