agent-stage 0.2.0 → 0.2.7

package/dist/commands/cleanup.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const cleanupCommand: Command;

package/dist/commands/{reset.js → cleanup.js}

@@ -6,8 +6,9 @@ import { rm, unlink } from 'fs/promises';
 import { existsSync } from 'fs';
 import { getWorkspaceDir, readRuntimeConfig, WORKSPACE_FILE } from '../utils/paths.js';
 const PROJECT_NAME = 'webapp';
-export const resetCommand = new Command('reset')
-    .description('Reset Agentstage by removing the project and workspace configuration')
+export const cleanupCommand = new Command()
+    .name('cleanup')
+    .description('Clean up Agentstage by removing the project and workspace configuration')
     .option('-y, --yes', 'Skip confirmation', false)
     .action(async (options) => {
     console.log();

package/dist/commands/dev/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const devCommand: Command;

package/dist/commands/dev/index.js

@@ -0,0 +1,11 @@
+import { Command } from 'commander';
+import { devInitCommand } from './init.js';
+import { devStartCommand } from './start.js';
+import { devStopCommand } from './stop.js';
+import { devStatusCommand } from './status.js';
+export const devCommand = new Command('dev')
+    .description('Development commands for Agentstage')
+    .addCommand(devInitCommand)
+    .addCommand(devStartCommand)
+    .addCommand(devStopCommand)
+    .addCommand(devStatusCommand);

package/dist/commands/dev/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const devInitCommand: Command;

package/dist/commands/dev/init.js

@@ -0,0 +1,231 @@
+import { Command } from 'commander';
+import * as p from '@clack/prompts';
+import consola from 'consola';
+import c from 'picocolors';
+import { execa } from 'execa';
+import { mkdir, writeFile, readdir, readFile, cp } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve, join, dirname } from 'pathe';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import { setWorkspaceDir } from '../../utils/paths.js';
+import { checkCloudflared, printInstallInstructions } from '../../utils/cloudflared.js';
+const PROJECT_NAME = 'webapp';
+// Get the template directory path (works in both dev and prod)
+function getTemplateDir() {
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const currentDir = dirname(currentFilePath);
+    // Production: template is next to dist
+    const prodPath = join(currentDir, '..', '..', '..', '..', 'template');
+    // Development: template is in the source
+    const devPath = join(currentDir, '..', '..', '..', '..', '..', 'template');
+    if (existsSync(prodPath)) {
+        return prodPath;
+    }
+    if (existsSync(devPath)) {
+        return devPath;
+    }
+    // Fallback: try current working directory relative paths
+    const cwdProdPath = join(process.cwd(), 'packages', 'cli', 'template');
+    if (existsSync(cwdProdPath)) {
+        return cwdProdPath;
+    }
+    throw new Error('Template directory not found. Please ensure the CLI is properly installed.');
+}
+export const devInitCommand = new Command('init')
+    .description('Initialize a new Agentstage project')
+    .option('-y, --yes', 'Use default settings (non-interactive)', false)
+    .option('--skip-cloudflared-check', 'Skip cloudflared installation check', false)
+    .action(async (options) => {
+    const name = PROJECT_NAME;
+    const useDefault = options.yes;
+    // 1. Check cloudflared installation
+    if (!options.skipCloudflaredCheck) {
+        const cloudflaredInfo = await checkCloudflared();
+        if (!cloudflaredInfo.installed) {
+            printInstallInstructions(cloudflaredInfo);
+            const shouldContinue = await p.confirm({
+                message: 'Continue with initialization? (You can install cloudflared later)',
+                initialValue: true,
+            });
+            if (p.isCancel(shouldContinue) || !shouldContinue) {
+                consola.info('Cancelled');
+                process.exit(0);
+            }
+        }
+        else {
+            consola.success(`Cloudflare Tunnel available: ${c.dim(cloudflaredInfo.version)}`);
+        }
+    }
+    // 2. 选择工作目录模式
+    let locationMode;
+    if (useDefault) {
+        locationMode = 'default';
+    }
+    else {
+        const result = await p.select({
+            message: 'Where to store the project?',
+            options: [
+                {
+                    value: 'default',
+                    label: `Default (~/.agentstage/${name})`,
+                    hint: 'Recommended',
+                },
+                {
+                    value: 'current',
+                    label: 'Current directory (./.agentstage)',
+                },
+                {
+                    value: 'custom',
+                    label: 'Custom path',
+                },
+            ],
+        });
+        if (p.isCancel(result)) {
+            consola.info('Cancelled');
+            return;
+        }
+        locationMode = result;
+    }
+    // 3. 确定目标目录
+    let targetDir;
+    switch (locationMode) {
+        case 'default':
+            targetDir = join(homedir(), '.agentstage', name);
+            break;
+        case 'current':
+            targetDir = join(process.cwd(), '.agentstage');
+            break;
+        case 'custom':
+            const customPath = await p.text({
+                message: 'Enter custom path:',
+                placeholder: '/path/to/project',
+                validate: (value) => {
+                    if (!value || value.trim() === '') {
+                        return 'Path is required';
+                    }
+                },
+            });
+            if (p.isCancel(customPath)) {
+                consola.info('Cancelled');
+                return;
+            }
+            targetDir = resolve(customPath);
+            break;
+        default:
+            targetDir = join(homedir(), '.agentstage', name);
+    }
+    // 4. 检查目录
+    if (existsSync(targetDir)) {
+        const files = await readdirSafe(targetDir);
+        if (files.length > 0) {
+            // 项目已存在，提示并退出
+            console.log();
+            consola.info('Project already initialized!');
+            console.log(`  Location: ${c.cyan(targetDir)}`);
+            console.log();
+            console.log(`  cd ${c.cyan(targetDir)}`);
+            console.log(`  ${c.cyan('agentstage dev start')}`);
+            console.log();
+            return;
+        }
+    }
+    // 5. 保存工作目录配置
+    await setWorkspaceDir(targetDir);
+    const s = p.spinner();
+    try {
+        // 6. 复制模板文件
+        s.start('Creating project from template...');
+        const templateDir = getTemplateDir();
+        await mkdir(targetDir, { recursive: true });
+        await copyTemplateFiles(templateDir, targetDir);
+        s.stop('Project template copied');
+        // 7. 更新 package.json 中的 workspace 依赖
+        s.start('Configuring project...');
+        await configurePackageJson(targetDir);
+        s.stop('Project configured');
+        // 8. 安装依赖
+        s.start('Installing dependencies...');
+        await installDependencies(targetDir);
+        s.stop('Dependencies installed');
+        // 完成
+        console.log();
+        consola.success('Project created successfully!');
+        console.log();
+        console.log(`  Location: ${c.cyan(targetDir)}`);
+        console.log();
+        console.log(`  cd ${c.cyan(targetDir)}`);
+        console.log(`  ${c.cyan('agentstage dev start')}`);
+        console.log();
+        console.log(c.dim('To expose your server to the internet:'));
+        console.log(`  ${c.cyan('agentstage dev start --tunnel')}`);
+        console.log();
+    }
+    catch (error) {
+        s.stop('Failed to create project');
+        consola.error(error.message);
+        process.exit(1);
+    }
+});
+async function readdirSafe(dir) {
+    try {
+        return await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+}
+async function copyTemplateFiles(templateDir, targetDir) {
+    const entries = await readdir(templateDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = join(templateDir, entry.name);
+        const destPath = join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            await mkdir(destPath, { recursive: true });
+            await copyTemplateFiles(srcPath, destPath);
+        }
+        else {
+            await cp(srcPath, destPath);
+        }
+    }
+}
+async function configurePackageJson(targetDir) {
+    const packageJsonPath = join(targetDir, 'package.json');
+    const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+    // Replace workspace:* with actual version or local path
+    // In dev mode (monorepo), use file: protocol to reference the local bridge package
+    // Check if we're in the monorepo by looking for packages/bridge from the CLI location
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const localBridgePath = resolve(join(dirname(currentFilePath), '..', '..', '..', '..', '..', 'bridge'));
+    const isDev = existsSync(localBridgePath);
+    if (isDev) {
+        // In dev mode, use file: protocol to reference the local bridge package
+        // This works with both npm and pnpm
+        packageJson.dependencies['@agentstage/bridge'] = `file:${localBridgePath}`;
+    }
+    else {
+        // Use npm version for production
+        packageJson.dependencies['@agentstage/bridge'] = '^0.1.0';
+    }
+    await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+async function installDependencies(targetDir) {
+    // Check if we're in the monorepo by looking for packages/bridge from the CLI location
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const localBridgePath = resolve(join(dirname(currentFilePath), '..', '..', '..', '..', '..', 'bridge'));
+    const isDev = existsSync(localBridgePath);
+    if (isDev) {
+        // In development mode (monorepo), use pnpm
+        try {
+            await execa('pnpm', ['install'], { cwd: targetDir, stdio: 'pipe' });
+        }
+        catch {
+            // Fallback to npm if pnpm is not available
+            await execa('npm', ['install'], { cwd: targetDir, stdio: 'pipe' });
+        }
+    }
+    else {
+        // In production, use npm
+        await execa('npm', ['install'], { cwd: targetDir, stdio: 'pipe' });
+    }
+}

package/dist/commands/dev/start.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const devStartCommand: Command;

package/dist/commands/dev/start.js

@@ -0,0 +1,145 @@
+import { Command } from 'commander';
+import * as p from '@clack/prompts';
+import consola from 'consola';
+import c from 'picocolors';
+import { execa } from 'execa';
+import { mkdir, writeFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join } from 'pathe';
+import { getWorkspaceDir, saveRuntimeConfig, isInitialized, readRuntimeConfig, } from '../../utils/paths.js';
+import { startTunnel, canStartTunnel, printTunnelInfo } from '../../utils/tunnel.js';
+import { checkCloudflared, printInstallInstructions } from '../../utils/cloudflared.js';
+export const devStartCommand = new Command('start')
+    .description('Start the Agentstage Runtime (Vite dev server with Bridge)')
+    .option('-p, --port <port>', 'Port to run the web server on', '3000')
+    .option('-t, --tunnel', 'Expose server to internet via Cloudflare Tunnel', false)
+    .option('--open', 'Open browser automatically', false)
+    .action(async (options) => {
+    // 1. 检查是否已初始化
+    if (!isInitialized()) {
+        consola.error('Project not initialized. Please run `agentstage init` first.');
+        process.exit(1);
+    }
+    const workspaceDir = await getWorkspaceDir();
+    const port = parseInt(options.port, 10);
+    // 2. 检查是否已运行
+    const existingConfig = await readRuntimeConfig();
+    if (existingConfig) {
+        try {
+            process.kill(existingConfig.pid, 0);
+            consola.warn(`Runtime is already running (PID: ${existingConfig.pid}, Port: ${existingConfig.port})`);
+            console.log(`  Web:    ${c.cyan(`http://localhost:${existingConfig.port}`)}`);
+            if (existingConfig.tunnelUrl) {
+                console.log(`  Public: ${c.cyan(c.underline(existingConfig.tunnelUrl))}`);
+            }
+            console.log(`  Bridge: ${c.cyan(`ws://localhost:${existingConfig.port}/_bridge`)}`);
+            return;
+        }
+        catch {
+            // 进程不存在，继续启动
+        }
+    }
+    // 3. 检查是否需要安装依赖
+    const nodeModulesPath = join(workspaceDir, 'node_modules');
+    if (!existsSync(nodeModulesPath)) {
+        const s = p.spinner();
+        s.start('Installing dependencies...');
+        try {
+            await execa('npm', ['install'], { cwd: workspaceDir, stdio: 'pipe' });
+            s.stop('Dependencies installed');
+        }
+        catch (error) {
+            s.stop('Failed to install dependencies');
+            consola.error(error.message);
+            process.exit(1);
+        }
+    }
+    // 4. 检查 cloudflared (如果请求了 tunnel)
+    let tunnelUrl;
+    if (options.tunnel) {
+        const canTunnel = await canStartTunnel();
+        if (!canTunnel) {
+            const info = await checkCloudflared();
+            printInstallInstructions(info);
+            consola.error('Cannot start with --tunnel: cloudflared not installed');
+            process.exit(1);
+        }
+    }
+    const s = p.spinner();
+    s.start('Starting Agentstage Runtime...');
+    try {
+        // 5. 启动 Vite dev server
+        const subprocess = execa('npx', ['vite', '--port', String(port), '--host'], {
+            cwd: workspaceDir,
+            detached: true,
+            stdio: 'ignore',
+        });
+        await mkdir(join(workspaceDir, '.agentstage'), { recursive: true });
+        // 6. 启动 tunnel (如果请求了)
+        if (options.tunnel) {
+            s.message('Starting Cloudflare Tunnel...');
+            try {
+                const tunnel = await startTunnel(port);
+                tunnelUrl = tunnel.url;
+                // Save tunnel info for stop command to use
+                const tunnelModulePath = join(workspaceDir, '.agentstage', 'tunnel.mjs');
+                // Write tunnel info for stop command to use
+                await writeFile(tunnelModulePath, `export const tunnelUrl = '${tunnelUrl}';\nexport const tunnelPid = ${subprocess.pid};\n`);
+            }
+            catch (tunnelError) {
+                s.stop('Tunnel failed to start');
+                consola.warn(`Tunnel error: ${tunnelError.message}`);
+                consola.info('Continuing without tunnel...');
+                // Kill the vite process since we're failing
+                subprocess.kill();
+                process.exit(1);
+            }
+        }
+        // 7. 保存运行时配置
+        const config = {
+            pid: subprocess.pid,
+            port,
+            startedAt: new Date().toISOString(),
+            tunnelUrl,
+        };
+        await saveRuntimeConfig(config);
+        // 8. 等待一下确保服务启动
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        s.stop('Runtime started successfully');
+        console.log();
+        consola.success('Agentstage Runtime is running');
+        console.log(`  Web:     ${c.cyan(`http://localhost:${port}`)}`);
+        if (tunnelUrl) {
+            printTunnelInfo(tunnelUrl);
+        }
+        console.log(`  Bridge:  ${c.cyan(`ws://localhost:${port}/_bridge`)}`);
+        console.log(`  Workspace: ${c.gray(workspaceDir)}`);
+        console.log();
+        if (options.open) {
+            const openUrl = tunnelUrl || `http://localhost:${port}`;
+            try {
+                await execa('open', [openUrl]);
+            }
+            catch {
+                // Ignore open errors
+            }
+        }
+        // Keep process alive to maintain tunnel
+        if (options.tunnel && tunnelUrl) {
+            console.log(c.dim('Press Ctrl+C to stop'));
+            process.on('SIGINT', async () => {
+                console.log();
+                consola.info('Shutting down...');
+                subprocess.kill();
+                process.exit(0);
+            });
+            // Keep running
+            await new Promise(() => { });
+        }
+    }
+    catch (error) {
+        s.stop('Failed to start runtime');
+        consola.error(error.message);
+        process.exit(1);
+    }
+});

package/dist/commands/dev/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const devStatusCommand: Command;

package/dist/commands/dev/status.js

@@ -0,0 +1,55 @@
+import { Command } from 'commander';
+import consola from 'consola';
+import c from 'picocolors';
+import { readRuntimeConfig, isInitialized, getWorkspaceDir } from '../../utils/paths.js';
+import { checkCloudflared } from '../../utils/cloudflared.js';
+export const devStatusCommand = new Command('status')
+    .description('Check the Agentstage Runtime status')
+    .action(async () => {
+    if (!isInitialized()) {
+        consola.error('Project not initialized. Please run `agentstage init` first.');
+        process.exit(1);
+    }
+    const workspaceDir = await getWorkspaceDir();
+    const config = await readRuntimeConfig();
+    console.log();
+    console.log(c.bold('Workspace:'), c.cyan(workspaceDir));
+    console.log();
+    // Check cloudflared
+    const cloudflared = await checkCloudflared();
+    console.log(c.bold('Cloudflare Tunnel:'));
+    if (cloudflared.installed) {
+        console.log(`  Status: ${c.green('✓ installed')}`);
+        console.log(`  Version: ${c.gray(cloudflared.version || 'unknown')}`);
+    }
+    else {
+        console.log(`  Status: ${c.yellow('✗ not installed')}`);
+        console.log(`  Install: ${c.gray(cloudflared.installCommand)}`);
+    }
+    console.log();
+    // Check runtime
+    console.log(c.bold('Runtime:'));
+    if (!config) {
+        console.log(`  Status: ${c.gray('stopped')}`);
+    }
+    else {
+        try {
+            process.kill(config.pid, 0);
+            console.log(`  Status: ${c.green('running')}`);
+            console.log(`  PID: ${c.gray(config.pid)}`);
+            console.log(`  Port: ${c.cyan(config.port)}`);
+            console.log(`  Local: ${c.cyan(`http://localhost:${config.port}`)}`);
+            if (config.tunnelUrl) {
+                console.log(`  Public: ${c.cyan(c.underline(config.tunnelUrl))}`);
+            }
+            console.log(`  Bridge: ${c.cyan(`ws://localhost:${config.port}/_bridge`)}`);
+            console.log(`  Started: ${c.gray(new Date(config.startedAt).toLocaleString())}`);
+        }
+        catch {
+            console.log(`  Status: ${c.yellow('stale (process not found)')}`);
+            console.log(`  Last PID: ${c.gray(config.pid)}`);
+            console.log(`  Last Port: ${c.gray(config.port)}`);
+        }
+    }
+    console.log();
+});

package/dist/commands/dev/stop.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const devStopCommand: Command;

package/dist/commands/dev/stop.js

@@ -0,0 +1,45 @@
+import { Command } from 'commander';
+import consola from 'consola';
+import c from 'picocolors';
+import { readRuntimeConfig, removeRuntimeConfig, isInitialized } from '../../utils/paths.js';
+export const devStopCommand = new Command('stop')
+    .description('Stop the Agentstage Runtime')
+    .action(async () => {
+    if (!isInitialized()) {
+        consola.error('Project not initialized. Please run `agentstage init` first.');
+        process.exit(1);
+    }
+    const config = await readRuntimeConfig();
+    if (!config) {
+        consola.warn('Runtime is not running');
+        return;
+    }
+    try {
+        // Check if process exists
+        process.kill(config.pid, 0);
+        // Kill the process
+        process.kill(config.pid, 'SIGTERM');
+        // Wait a bit and check if it's still running
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        try {
+            process.kill(config.pid, 0);
+            // Still running, force kill
+            process.kill(config.pid, 'SIGKILL');
+        }
+        catch {
+            // Process already stopped
+        }
+        await removeRuntimeConfig();
+        consola.success('Runtime stopped');
+        console.log(`  PID: ${c.gray(config.pid)}`);
+        console.log(`  Port: ${c.gray(config.port)}`);
+        if (config.tunnelUrl) {
+            console.log(`  Tunnel: ${c.gray(config.tunnelUrl)}`);
+        }
+    }
+    catch {
+        // Process doesn't exist, clean up stale config
+        await removeRuntimeConfig();
+        consola.info('Runtime was not running (stale config cleaned up)');
+    }
+});

package/dist/commands/doctor.js

@@ -153,7 +153,7 @@ export const doctorCommand = new Command('doctor')
     try {
         const workspaceDir = await getWorkspaceDir();
         const nodeModulesPath = join(workspaceDir, 'node_modules');
-        const bridgePath = join(nodeModulesPath, '@agentstage', 'bridge');
+        const bridgePath = join(nodeModulesPath, '@agentstage/bridge');
         if (!existsSync(nodeModulesPath)) {
             results.push({
                 name: 'Dependencies',
@@ -166,7 +166,7 @@ export const doctorCommand = new Command('doctor')
             results.push({
                 name: 'Dependencies',
                 status: 'error',
-                message: 'agent-stage-bridge not installed',
+                message: '@agentstage/bridge not installed',
                 details: ['Run: npm install @agentstage/bridge'],
             });
         }

package/dist/commands/exec.js

@@ -1,56 +1,72 @@
 import { Command } from 'commander';
 import consola from 'consola';
-import { BridgeClient } from 'agent-stage-bridge/sdk';
-import { readRuntimeConfig, isInitialized } from '../utils/paths.js';
+import { join } from 'pathe';
+import { FileStore } from '@agentstage/bridge';
+import { BridgeClient } from '@agentstage/bridge/sdk';
+import { isInitialized, readRuntimeConfig, getPagesDir } from '../utils/paths.js';
 export const execCommand = new Command('exec')
     .description('Execute an action on a page or set state')
     .argument('<page>', 'Page ID')
     .argument('[action]', 'Action name')
     .argument('[payload]', 'Action payload as JSON')
     .option('-s, --state <json>', 'Set state directly')
+    .option('--wait [timeoutMs]', 'Wait for browser ACK (optional timeout in ms)')
     .action(async (pageId, action, payload, options) => {
     try {
-        // 1. 检查是否已初始化
         if (!isInitialized()) {
             consola.error('Project not initialized. Please run `agentstage init` first.');
             process.exit(1);
         }
-        // 2. 检查是否已启动
-        const config = await readRuntimeConfig();
-        if (!config) {
-            consola.error('Runtime is not running. Please run `agentstage start` first.');
-            process.exit(1);
-        }
-        const client = new BridgeClient(`ws://localhost:${config.port}/_bridge`);
-        await client.connect();
-        // 查找 page 对应的 store
-        const stores = await client.listStores();
-        consola.info(`Found ${stores.length} stores:`, stores.map(s => `${s.pageId}:${s.storeKey} (${s.id})`));
-        const store = stores.find(s => s.pageId === pageId && s.storeKey === 'main');
-        if (!store) {
-            consola.error(`Page "${pageId}" not found`);
-            consola.info('Available pages:', stores.map(s => s.pageId));
-            client.disconnect();
-            process.exit(1);
-        }
+        const pagesDir = await getPagesDir();
+        const fileStore = new FileStore({ pagesDir });
+        const storePath = join(pagesDir, pageId, 'store.json');
         if (options.state) {
-            // 设置 state
             const state = JSON.parse(options.state);
-            await client.setState(store.id, state);
-            consola.success('State updated');
+            const waitForAck = options.wait !== undefined && options.wait !== false;
+            if (waitForAck) {
+                const timeoutMs = typeof options.wait === 'string' && Number.isFinite(Number(options.wait))
+                    ? Number(options.wait)
+                    : 5000;
+                const config = await readRuntimeConfig();
+                if (!config) {
+                    consola.error('Bridge runtime is not running. Start it first or remove --wait.');
+                    process.exit(1);
+                }
+                const client = new BridgeClient(`ws://localhost:${config.port}/_bridge`);
+                await client.connect();
+                try {
+                    const result = await client.setStateByKey(pageId, 'main', state, {
+                        waitForAck: true,
+                        timeoutMs,
+                    });
+                    consola.success(`State updated with ACK (${storePath}, v${result.version})`);
+                }
+                finally {
+                    client.disconnect();
+                }
+            }
+            else {
+                const saved = await fileStore.save(pageId, {
+                    state,
+                    version: 0,
+                    updatedAt: new Date().toISOString(),
+                    pageId,
+                });
+                consola.success(`State updated (${storePath}, v${saved.version})`);
+            }
         }
         else if (action) {
-            // 执行 action
-            const actionPayload = payload ? JSON.parse(payload) : undefined;
-            await client.dispatch(store.id, { type: action, payload: actionPayload });
-            consola.success(`Action "${action}" executed`);
+            // 保留命令参数兼容性，但文件模式仅支持直接写 state
+            if (payload) {
+                JSON.parse(payload);
+            }
+            consola.error('File mode only supports --state. Action dispatch requires a live Bridge connection.');
+            process.exit(1);
         }
         else {
             consola.error('Please specify an action or use --state');
-            client.disconnect();
             process.exit(1);
         }
-        client.disconnect();
     }
     catch (error) {
         consola.error('Failed to execute:', error.message);

package/dist/commands/guide.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const guideCommand: Command;