@synergenius/flow-weaver 0.22.10 → 0.23.1

package/dist/agent/device-connection.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Device Connection — WebSocket client for connecting a local machine
+ * to the Flow Weaver platform as a mounted device.
+ *
+ * This is the transport layer. Packs register their own request handlers
+ * on top of this connection (e.g., improve status, bot management).
+ *
+ * The platform relays Studio requests to connected devices and forwards
+ * device events to Studio subscribers.
+ */
+export interface DeviceInfo {
+    name: string;
+    hostname: string;
+    projectDir: string;
+    platform: string;
+    capabilities: string[];
+}
+export interface DeviceConnectionOptions {
+    platformUrl: string;
+    token: string;
+    projectDir: string;
+    deviceName?: string;
+    onConnect?: () => void;
+    onDisconnect?: (code: number) => void;
+    onEvent?: (event: DeviceEvent) => void;
+    logger?: (msg: string) => void;
+}
+export interface DeviceEvent {
+    type: string;
+    data: Record<string, unknown>;
+    timestamp: number;
+}
+type RequestHandler = (method: string, params: Record<string, unknown>) => Promise<unknown>;
+export declare class DeviceConnection {
+    private ws;
+    private heartbeatInterval;
+    private reconnectTimeout;
+    private requestHandlers;
+    private connected;
+    private shouldReconnect;
+    private readonly options;
+    private readonly deviceInfo;
+    private readonly log;
+    constructor(options: DeviceConnectionOptions);
+    /**
+     * Add a capability to advertise to the platform.
+     */
+    addCapability(capability: string): void;
+    /**
+     * Register a handler for incoming requests from the platform.
+     */
+    onRequest(method: string, handler: RequestHandler): void;
+    /**
+     * Connect to the platform. Reconnects automatically on disconnect.
+     */
+    connect(): Promise<void>;
+    /**
+     * Emit an event to the platform.
+     */
+    emit(event: DeviceEvent): void;
+    /**
+     * Disconnect from the platform. No auto-reconnect.
+     */
+    disconnect(): void;
+    isConnected(): boolean;
+    getDeviceInfo(): Readonly<DeviceInfo>;
+    private send;
+    private handleMessage;
+    private scheduleReconnect;
+}
+export {};
+//# sourceMappingURL=device-connection.d.ts.map

package/dist/agent/device-connection.js

@@ -0,0 +1,177 @@
+/**
+ * Device Connection — WebSocket client for connecting a local machine
+ * to the Flow Weaver platform as a mounted device.
+ *
+ * This is the transport layer. Packs register their own request handlers
+ * on top of this connection (e.g., improve status, bot management).
+ *
+ * The platform relays Studio requests to connected devices and forwards
+ * device events to Studio subscribers.
+ */
+export class DeviceConnection {
+    ws = null;
+    heartbeatInterval = null;
+    reconnectTimeout = null;
+    requestHandlers = new Map();
+    connected = false;
+    shouldReconnect = true;
+    options;
+    deviceInfo;
+    log;
+    constructor(options) {
+        this.options = options;
+        this.log = options.logger ?? (() => { });
+        const os = require('node:os');
+        this.deviceInfo = {
+            name: options.deviceName ?? os.hostname(),
+            hostname: os.hostname(),
+            projectDir: options.projectDir,
+            platform: process.platform,
+            capabilities: [],
+        };
+    }
+    /**
+     * Add a capability to advertise to the platform.
+     */
+    addCapability(capability) {
+        if (!this.deviceInfo.capabilities.includes(capability)) {
+            this.deviceInfo.capabilities.push(capability);
+        }
+    }
+    /**
+     * Register a handler for incoming requests from the platform.
+     */
+    onRequest(method, handler) {
+        this.requestHandlers.set(method, handler);
+    }
+    /**
+     * Connect to the platform. Reconnects automatically on disconnect.
+     */
+    async connect() {
+        const wsUrl = this.options.platformUrl
+            .replace(/^http/, 'ws')
+            .replace(/\/$/, '') + '/ws/device';
+        this.log(`Connecting to ${wsUrl}...`);
+        this.shouldReconnect = true;
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(`${wsUrl}?token=${encodeURIComponent(this.options.token)}`);
+            }
+            catch (err) {
+                reject(err);
+                return;
+            }
+            this.ws.addEventListener('open', () => {
+                this.connected = true;
+                this.log(`Connected as "${this.deviceInfo.name}"`);
+                // Send device registration
+                this.send({ type: 'device:register', device: this.deviceInfo });
+                // Start heartbeat
+                this.heartbeatInterval = setInterval(() => {
+                    if (this.ws?.readyState === WebSocket.OPEN) {
+                        this.send({ type: 'heartbeat', timestamp: Date.now() });
+                    }
+                }, 30_000);
+                this.options.onConnect?.();
+                resolve();
+            });
+            this.ws.addEventListener('message', async (event) => {
+                try {
+                    const msg = JSON.parse(typeof event.data === 'string' ? event.data : String(event.data));
+                    await this.handleMessage(msg);
+                }
+                catch (err) {
+                    this.log(`Parse error: ${err instanceof Error ? err.message : err}`);
+                }
+            });
+            this.ws.addEventListener('close', (event) => {
+                this.connected = false;
+                if (this.heartbeatInterval)
+                    clearInterval(this.heartbeatInterval);
+                this.options.onDisconnect?.(event.code);
+                if (this.shouldReconnect) {
+                    this.log(`Disconnected (${event.code}). Reconnecting in 5s...`);
+                    this.scheduleReconnect();
+                }
+            });
+            this.ws.addEventListener('error', () => {
+                if (!this.connected) {
+                    reject(new Error('WebSocket connection failed'));
+                }
+                else {
+                    this.log('Connection error');
+                }
+            });
+        });
+    }
+    /**
+     * Emit an event to the platform.
+     */
+    emit(event) {
+        if (!this.connected)
+            return;
+        this.send({ type: 'device:event', event });
+        this.options.onEvent?.(event);
+    }
+    /**
+     * Disconnect from the platform. No auto-reconnect.
+     */
+    disconnect() {
+        this.shouldReconnect = false;
+        if (this.heartbeatInterval)
+            clearInterval(this.heartbeatInterval);
+        if (this.reconnectTimeout)
+            clearTimeout(this.reconnectTimeout);
+        if (this.ws) {
+            this.ws.close(1000, 'Device disconnecting');
+            this.ws = null;
+        }
+        this.connected = false;
+    }
+    isConnected() {
+        return this.connected;
+    }
+    getDeviceInfo() {
+        return this.deviceInfo;
+    }
+    // --- Private ---
+    send(msg) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(msg));
+        }
+    }
+    async handleMessage(msg) {
+        const type = String(msg.type ?? '');
+        const requestId = String(msg.requestId ?? '');
+        if (type === 'request') {
+            const method = String(msg.method ?? '');
+            const params = msg.params ?? {};
+            const handler = this.requestHandlers.get(method);
+            if (!handler) {
+                this.send({ type: 'response', requestId, success: false, error: `Unknown method: ${method}` });
+                return;
+            }
+            try {
+                const result = await handler(method, params);
+                this.send({ type: 'response', requestId, success: true, result });
+            }
+            catch (err) {
+                this.send({ type: 'response', requestId, success: false, error: err instanceof Error ? err.message : String(err) });
+            }
+        }
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimeout)
+            clearTimeout(this.reconnectTimeout);
+        this.reconnectTimeout = setTimeout(async () => {
+            try {
+                await this.connect();
+            }
+            catch {
+                this.log('Reconnect failed. Retrying in 10s...');
+                this.reconnectTimeout = setTimeout(() => this.scheduleReconnect(), 10_000);
+            }
+        }, 5_000);
+    }
+}
+//# sourceMappingURL=device-connection.js.map

package/dist/agent/index.d.ts

@@ -17,4 +17,6 @@ export { createMcpBridge } from './mcp-bridge.js';
 export { CliSession, getOrCreateCliSession, killCliSession, killAllCliSessions, } from './cli-session.js';
 export { buildSafeEnv, buildSafeSpawnOpts, MINIMAL_PATH, ENV_ALLOWLIST } from './env-allowlist.js';
 export { StreamJsonParser } from './streaming.js';
+export { DeviceConnection } from './device-connection.js';
+export type { DeviceConnectionOptions, DeviceInfo, DeviceEvent } from './device-connection.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/agent/index.js

@@ -19,4 +19,6 @@ export { CliSession, getOrCreateCliSession, killCliSession, killAllCliSessions,
 export { buildSafeEnv, buildSafeSpawnOpts, MINIMAL_PATH, ENV_ALLOWLIST } from './env-allowlist.js';
 // Stream parser (for custom providers)
 export { StreamJsonParser } from './streaming.js';
+// Device connection (mount local machine into platform Studio)
+export { DeviceConnection } from './device-connection.js';
 //# sourceMappingURL=index.js.map

package/dist/agent/providers/claude-cli.d.ts

@@ -14,6 +14,7 @@ export declare class ClaudeCliProvider implements AgentProvider {
     private mcpConfigPath;
     private spawnFn;
     private timeout;
+    private disallowedTools;
     constructor(options?: ClaudeCliProviderOptions);
     stream(messages: AgentMessage[], tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
 }

package/dist/agent/providers/claude-cli.js

@@ -16,12 +16,14 @@ export class ClaudeCliProvider {
     mcpConfigPath;
     spawnFn;
     timeout;
+    disallowedTools;
     constructor(options = {}) {
         this.binPath = options.binPath ?? 'claude';
         this.cwd = options.cwd ?? process.cwd();
         this.env = options.env ?? process.env;
         this.model = options.model;
         this.mcpConfigPath = options.mcpConfigPath;
+        this.disallowedTools = options.disallowedTools ?? [];
         this.spawnFn = options.spawnFn ?? ((cmd, args, opts) => nodeSpawn(cmd, args, { ...opts, stdio: opts.stdio }));
         this.timeout = options.timeout ?? 600_000;
     }
@@ -53,6 +55,7 @@ export class ClaudeCliProvider {
             'bypassPermissions',
             ...(systemPrompt ? ['--system-prompt', systemPrompt] : []),
             ...(mcpConfigPath ? ['--mcp-config', mcpConfigPath, '--strict-mcp-config'] : []),
+            ...(this.disallowedTools.length > 0 ? ['--disallowed-tools', this.disallowedTools.join(' ')] : []),
             ...(model ? ['--model', model] : []),
         ];
         // Spawn the CLI process

package/dist/agent/types.d.ts

@@ -131,6 +131,8 @@ export interface ClaudeCliProviderOptions {
     spawnFn?: SpawnFn;
     /** CLI timeout in milliseconds. Defaults to 120000. */
     timeout?: number;
+    /** Disable specific built-in tools (e.g. ['Read', 'Edit', 'Write', 'Bash'] to force MCP tools). */
+    disallowedTools?: string[];
 }
 export interface CliSessionOptions {
     /** Absolute path to the claude binary. */

package/dist/cli/commands/auth.js

@@ -4,80 +4,183 @@ import { PlatformClient } from '../config/platform-client.js';
 export async function loginCommand(options) {
     const platformUrl = options.platformUrl ?? getPlatformUrl();
     console.log('');
-    console.log('  \x1b[1mFlow Weaver Login\x1b[0m');
-    console.log(`  \x1b[2mPlatform: ${platformUrl}\x1b[0m`);
+    console.log('  \x1b[1mFlow Weaver Cloud\x1b[0m \x1b[2m(flowweaver.ai)\x1b[0m');
     console.log('');
-    // Validate platform reachable
+    // API key mode (for CI/headless)
+    if (options.apiKey) {
+        await loginWithApiKey(options.apiKey, platformUrl);
+        return;
+    }
+    // Email mode (explicit --email flag)
+    if (options.email) {
+        await loginWithEmail(options.email, platformUrl);
+        return;
+    }
+    // Default: browser-first device auth
+    await loginWithBrowser(platformUrl);
+}
+async function loginWithBrowser(platformUrl) {
+    // Step 1: Request device code
+    let deviceCode;
+    let userCode;
+    let verificationUrl;
+    let interval;
     try {
-        const resp = await fetch(`${platformUrl}/ready`);
-        if (!resp.ok)
-            throw new Error();
+        const resp = await fetch(`${platformUrl}/auth/device`, { method: 'POST' });
+        if (!resp.ok) {
+            // Platform doesn't support device auth — fall back to email
+            console.log('  \x1b[33m⚠\x1b[0m Device auth not available. Using email login.');
+            console.log('');
+            const email = await prompt('  Email: ');
+            await loginWithEmail(email, platformUrl);
+            return;
+        }
+        const data = await resp.json();
+        deviceCode = data.deviceCode;
+        userCode = data.userCode;
+        verificationUrl = data.verificationUrl;
+        interval = data.interval ?? 5;
     }
     catch {
-        console.error('  \x1b[31m✗\x1b[0m Cannot connect to platform');
-        console.error(`    Check: ${platformUrl}`);
+        console.error('  \x1b[31m✗\x1b[0m Cannot connect to flowweaver.ai');
+        console.error('    Check your internet connection or set FW_PLATFORM_URL');
         process.exit(1);
+        return;
     }
-    let token;
-    let email;
-    let plan;
-    let userId;
-    if (options.apiKey) {
-        // API key auth
-        token = options.apiKey;
-        const client = new PlatformClient({ token, email: '', plan: 'free', platformUrl, expiresAt: Infinity });
-        try {
-            const user = await client.getUser();
-            email = user.email;
-            plan = user.plan;
-            userId = user.id;
-        }
-        catch {
-            console.error('  \x1b[31m✗\x1b[0m Invalid API key');
-            process.exit(1);
-            return;
-        }
+    // Step 2: Open browser
+    const authUrl = `${verificationUrl}?code=${userCode}`;
+    console.log(`  Your code: \x1b[1m${userCode}\x1b[0m`);
+    console.log('');
+    try {
+        const { exec } = await import('child_process');
+        const openCmd = process.platform === 'darwin' ? 'open'
+            : process.platform === 'win32' ? 'start'
+                : 'xdg-open';
+        exec(`${openCmd} "${authUrl}"`);
+        console.log('  \x1b[2mOpening browser...\x1b[0m');
     }
-    else {
-        // Email/password auth
-        email = options.email ?? await prompt('  Email: ');
-        const password = await prompt('  Password: ', true);
+    catch {
+        console.log(`  Open this URL in your browser:`);
+        console.log(`  \x1b[36m${authUrl}\x1b[0m`);
+    }
+    console.log('');
+    // Step 3: Poll for completion
+    process.stdout.write('  Waiting for authentication...');
+    let cancelled = false;
+    const sigHandler = () => { cancelled = true; };
+    process.on('SIGINT', sigHandler);
+    const maxAttempts = 120; // 10 minutes at 5s intervals
+    for (let i = 0; i < maxAttempts && !cancelled; i++) {
+        await new Promise(r => setTimeout(r, interval * 1000));
         try {
-            const resp = await fetch(`${platformUrl}/auth/login`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ email, password }),
-            });
-            if (!resp.ok) {
-                const err = await resp.json().catch(() => ({ error: 'Login failed' }));
-                console.error(`\n  \x1b[31m✗\x1b[0m ${err.error}`);
+            const resp = await fetch(`${platformUrl}/auth/device/poll?deviceCode=${deviceCode}`);
+            if (!resp.ok)
+                continue;
+            const data = await resp.json();
+            if (data.status === 'approved' && data.token && data.user) {
+                process.stdout.write(' \x1b[32m✓\x1b[0m\n\n');
+                saveCredentials({
+                    token: data.token,
+                    email: data.user.email,
+                    plan: data.user.plan,
+                    platformUrl,
+                    expiresAt: Date.now() + 7 * 24 * 60 * 60 * 1000,
+                    userId: data.user.id,
+                });
+                console.log(`  Logged in as \x1b[1m${data.user.email}\x1b[0m (${data.user.plan} plan)`);
+                console.log('');
+                console.log('  Try: \x1b[36mweaver assistant\x1b[0m');
+                console.log('');
+                process.removeListener('SIGINT', sigHandler);
+                return;
+            }
+            if (data.status === 'expired') {
+                process.stdout.write(' \x1b[31mtimed out\x1b[0m\n\n');
+                console.log('  Code expired. Run \x1b[36mfw login\x1b[0m again.');
+                console.log('');
+                process.removeListener('SIGINT', sigHandler);
                 process.exit(1);
                 return;
             }
-            const data = await resp.json();
-            token = data.token;
-            email = data.user.email;
-            plan = data.user.plan;
-            userId = data.user.id;
+            if (data.status === 'denied') {
+                process.stdout.write(' \x1b[31mdenied\x1b[0m\n\n');
+                console.log('  Access denied.');
+                console.log('');
+                process.removeListener('SIGINT', sigHandler);
+                process.exit(1);
+                return;
+            }
+            // Still pending — show a dot for progress
+            if (i % 4 === 3)
+                process.stdout.write('.');
         }
-        catch (err) {
-            console.error(`\n  \x1b[31m✗\x1b[0m ${err instanceof Error ? err.message : 'Login failed'}`);
-            process.exit(1);
-            return;
+        catch {
+            // Network error — keep trying
         }
     }
-    const expiresAt = options.apiKey
-        ? Date.now() + 365 * 24 * 60 * 60 * 1000 // 1 year for API keys
-        : Date.now() + 7 * 24 * 60 * 60 * 1000; // 7 days for JWT
-    saveCredentials({ token, email, plan: plan, platformUrl, expiresAt, userId });
-    console.log('');
+    process.removeListener('SIGINT', sigHandler);
+    if (cancelled) {
+        process.stdout.write(' \x1b[33mcancelled\x1b[0m\n\n');
+    }
+    else {
+        process.stdout.write(' \x1b[31mtimed out\x1b[0m\n\n');
+        console.log('  Authentication timed out. Run \x1b[36mfw login\x1b[0m again.');
+        console.log('');
+    }
+}
+async function loginWithApiKey(apiKey, platformUrl) {
+    const client = new PlatformClient({ token: apiKey, email: '', plan: 'free', platformUrl, expiresAt: Infinity });
+    let email;
+    let plan;
+    let userId;
+    try {
+        const user = await client.getUser();
+        email = user.email;
+        plan = user.plan;
+        userId = user.id;
+    }
+    catch {
+        console.error('  \x1b[31m✗\x1b[0m Invalid API key');
+        process.exit(1);
+        return;
+    }
+    const expiresAt = Date.now() + 365 * 24 * 60 * 60 * 1000; // 1 year for API keys
+    saveCredentials({ token: apiKey, email, plan: plan, platformUrl, expiresAt, userId });
     console.log(`  \x1b[32m✓\x1b[0m Logged in as \x1b[1m${email}\x1b[0m (${plan} plan)`);
     console.log('');
-    console.log('  What\'s unlocked:');
-    console.log('    \x1b[36mfw deploy src/workflow.ts\x1b[0m   \x1b[2m# deploy to cloud\x1b[0m');
-    console.log('    \x1b[36mfw status\x1b[0m                   \x1b[2m# see deployments + usage\x1b[0m');
-    console.log('    \x1b[36mweaver assistant\x1b[0m             \x1b[2m# AI with platform credits\x1b[0m');
-    console.log('');
+}
+async function loginWithEmail(email, platformUrl) {
+    const password = await prompt('  Password: ', true);
+    try {
+        const resp = await fetch(`${platformUrl}/auth/login`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ email, password }),
+        });
+        if (!resp.ok) {
+            const err = await resp.json().catch(() => ({ error: 'Login failed' }));
+            console.error(`\n  \x1b[31m✗\x1b[0m ${err.error}`);
+            process.exit(1);
+            return;
+        }
+        const data = await resp.json();
+        const expiresAt = Date.now() + 7 * 24 * 60 * 60 * 1000; // 7 days for JWT
+        saveCredentials({
+            token: data.token,
+            email: data.user.email,
+            plan: data.user.plan,
+            platformUrl,
+            expiresAt,
+            userId: data.user.id,
+        });
+        console.log('');
+        console.log(`  \x1b[32m✓\x1b[0m Logged in as \x1b[1m${data.user.email}\x1b[0m (${data.user.plan} plan)`);
+        console.log('');
+    }
+    catch (err) {
+        console.error(`\n  \x1b[31m✗\x1b[0m ${err instanceof Error ? err.message : 'Login failed'}`);
+        process.exit(1);
+    }
 }
 export async function logoutCommand() {
     clearCredentials();
@@ -99,6 +202,11 @@ export async function authStatusCommand() {
     console.log(`  Platform: ${creds.platformUrl}`);
     console.log(`  Token expires in: ${expiresIn}h`);
     console.log('');
+    console.log('  Commands unlocked:');
+    console.log('    \x1b[36mfw deploy <file>\x1b[0m         deploy to cloud');
+    console.log('    \x1b[36mfw cloud-status\x1b[0m          see deployments + usage');
+    console.log('    \x1b[36mweaver assistant\x1b[0m          AI with platform credits');
+    console.log('');
 }
 function prompt(message, hidden = false) {
     return new Promise((resolve) => {

package/dist/cli/commands/connect.d.ts

@@ -0,0 +1,2 @@
+export declare function handleConnect(projectDir: string): Promise<void>;
+//# sourceMappingURL=connect.d.ts.map

package/dist/cli/commands/connect.js

@@ -0,0 +1,69 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { DeviceConnection } from '../../agent/device-connection.js';
+export async function handleConnect(projectDir) {
+    // Load credentials
+    const credPath = path.join(os.homedir(), '.fw', 'credentials.json');
+    if (!fs.existsSync(credPath)) {
+        console.error('\n  Not logged in. Run: fw login\n');
+        process.exit(1);
+    }
+    const creds = JSON.parse(fs.readFileSync(credPath, 'utf-8'));
+    if (!creds.token || !creds.platformUrl || creds.expiresAt < Date.now()) {
+        console.error('\n  Credentials expired. Run: fw login\n');
+        process.exit(1);
+    }
+    const conn = new DeviceConnection({
+        platformUrl: creds.platformUrl,
+        token: creds.token,
+        projectDir,
+        deviceName: path.basename(projectDir),
+        logger: (msg) => process.stderr.write(`  \x1b[2m${msg}\x1b[0m\n`),
+    });
+    // Register basic file handlers (any project can use these)
+    conn.addCapability('file_read');
+    conn.addCapability('file_list');
+    conn.onRequest('file:read', async (_method, params) => {
+        const filePath = path.resolve(projectDir, String(params.path ?? ''));
+        if (!filePath.startsWith(projectDir))
+            throw new Error('Path outside project directory');
+        if (!fs.existsSync(filePath))
+            throw new Error('File not found');
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory())
+            return { type: 'directory', entries: fs.readdirSync(filePath) };
+        if (stat.size > 1_048_576)
+            throw new Error('File too large (>1MB)');
+        return { type: 'file', content: fs.readFileSync(filePath, 'utf-8') };
+    });
+    conn.onRequest('file:list', async (_method, params) => {
+        const dirPath = path.resolve(projectDir, String(params.path ?? '.'));
+        if (!dirPath.startsWith(projectDir))
+            throw new Error('Path outside project directory');
+        if (!fs.existsSync(dirPath))
+            throw new Error('Directory not found');
+        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+        return entries
+            .filter(e => !e.name.startsWith('.') && e.name !== 'node_modules' && e.name !== 'dist')
+            .map(e => ({ name: e.name, type: e.isDirectory() ? 'directory' : 'file', path: path.relative(projectDir, path.join(dirPath, e.name)) }));
+    });
+    console.log('');
+    console.log('  \x1b[1mflow-weaver connect\x1b[0m');
+    console.log(`  \x1b[2mProject: ${path.basename(projectDir)}\x1b[0m`);
+    console.log(`  \x1b[2mPlatform: ${creds.platformUrl}\x1b[0m`);
+    console.log('');
+    try {
+        await conn.connect();
+        console.log('  \x1b[2mPress Ctrl+C to disconnect.\x1b[0m\n');
+        await new Promise((resolve) => {
+            process.on('SIGINT', () => { console.log('\n  \x1b[2mDisconnecting...\x1b[0m'); conn.disconnect(); resolve(); });
+            process.on('SIGTERM', () => { conn.disconnect(); resolve(); });
+        });
+    }
+    catch (err) {
+        console.error(`  \x1b[31m✗\x1b[0m Connection failed: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=connect.js.map

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

@@ -18,6 +18,8 @@ export interface InitOptions {
     useCase?: string;
     mcp?: boolean;
     agent?: boolean;
+    withWeaver?: boolean;
+    weaver?: boolean;
 }
 export interface InitConfig {
     projectName: string;