@synergenius/flow-weaver 0.23.0 → 0.23.3

package/dist/agent/device-connection.js

@@ -0,0 +1,184 @@
+/**
+ * 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);
+        }
+    }
+    /**
+     * Set the list of packs that contributed device handlers.
+     * The platform uses this to auto-install packs in the user's workspace.
+     */
+    setPacks(packs) {
+        this.deviceInfo.packs = packs;
+    }
+    /**
+     * 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

@@ -3,8 +3,9 @@ import { loadCredentials, saveCredentials, clearCredentials, getPlatformUrl } fr
 import { PlatformClient } from '../config/platform-client.js';
 export async function loginCommand(options) {
     const platformUrl = options.platformUrl ?? getPlatformUrl();
+    const displayUrl = platformUrl.replace(/^https?:\/\//, '');
     console.log('');
-    console.log('  \x1b[1mFlow Weaver Cloud\x1b[0m \x1b[2m(flowweaver.ai)\x1b[0m');
+    console.log(`  \x1b[1mFlow Weaver\x1b[0m \x1b[2m(${displayUrl})\x1b[0m`);
     console.log('');
     // API key mode (for CI/headless)
     if (options.apiKey) {
@@ -42,8 +43,8 @@ async function loginWithBrowser(platformUrl) {
         interval = data.interval ?? 5;
     }
     catch {
-        console.error('  \x1b[31m✗\x1b[0m Cannot connect to flowweaver.ai');
-        console.error('    Check your internet connection or set FW_PLATFORM_URL');
+        console.error(`  \x1b[31m✗\x1b[0m Cannot connect to ${platformUrl}`);
+        console.error('    Check the URL or set FW_PLATFORM_URL');
         process.exit(1);
         return;
     }
@@ -65,20 +66,24 @@ async function loginWithBrowser(platformUrl) {
     }
     console.log('');
     // Step 3: Poll for completion
-    process.stdout.write('  Waiting for authentication...');
+    process.stderr.write('  Waiting for approval');
     let cancelled = false;
     const sigHandler = () => { cancelled = true; };
     process.on('SIGINT', sigHandler);
     const maxAttempts = 120; // 10 minutes at 5s intervals
+    let networkErrors = 0;
     for (let i = 0; i < maxAttempts && !cancelled; i++) {
         await new Promise(r => setTimeout(r, interval * 1000));
         try {
             const resp = await fetch(`${platformUrl}/auth/device/poll?deviceCode=${deviceCode}`);
-            if (!resp.ok)
+            networkErrors = 0; // reset on successful connection
+            if (!resp.ok) {
+                process.stderr.write('.');
                 continue;
+            }
             const data = await resp.json();
             if (data.status === 'approved' && data.token && data.user) {
-                process.stdout.write(' \x1b[32m✓\x1b[0m\n\n');
+                process.stderr.write(' \x1b[32m✓\x1b[0m\n\n');
                 saveCredentials({
                     token: data.token,
                     email: data.user.email,
@@ -95,7 +100,7 @@ async function loginWithBrowser(platformUrl) {
                 return;
             }
             if (data.status === 'expired') {
-                process.stdout.write(' \x1b[31mtimed out\x1b[0m\n\n');
+                process.stderr.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);
@@ -103,27 +108,30 @@ async function loginWithBrowser(platformUrl) {
                 return;
             }
             if (data.status === 'denied') {
-                process.stdout.write(' \x1b[31mdenied\x1b[0m\n\n');
+                process.stderr.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('.');
+            // Still pending — show a dot every poll
+            process.stderr.write('.');
         }
         catch {
-            // Network error — keep trying
+            networkErrors++;
+            if (networkErrors >= 3) {
+                process.stderr.write(' \x1b[33m!\x1b[0m');
+                networkErrors = 0;
+            }
         }
     }
     process.removeListener('SIGINT', sigHandler);
     if (cancelled) {
-        process.stdout.write(' \x1b[33mcancelled\x1b[0m\n\n');
+        process.stderr.write(' \x1b[33mcancelled\x1b[0m\n\n');
     }
     else {
-        process.stdout.write(' \x1b[31mtimed out\x1b[0m\n\n');
+        process.stderr.write(' \x1b[31mtimed out\x1b[0m\n\n');
         console.log('  Authentication timed out. Run \x1b[36mfw login\x1b[0m again.');
         console.log('');
     }
@@ -209,23 +217,24 @@ export async function authStatusCommand() {
     console.log('');
 }
 function prompt(message, hidden = false) {
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-        if (hidden && process.stdin.isTTY) {
-            // Hide password input
+    if (hidden && process.stdin.isTTY) {
+        // Raw-mode password input — no readline (it competes for stdin)
+        return new Promise((resolve) => {
             process.stderr.write(message);
             process.stdin.setRawMode(true);
+            process.stdin.resume();
             let input = '';
             const handler = (key) => {
                 const ch = key.toString();
                 if (ch === '\r' || ch === '\n') {
                     process.stdin.setRawMode(false);
+                    process.stdin.pause();
                     process.stdin.removeListener('data', handler);
                     process.stderr.write('\n');
-                    rl.close();
                     resolve(input);
                 }
                 else if (ch === '\x03') { // Ctrl+C
+                    process.stdin.setRawMode(false);
                     process.exit(1);
                 }
                 else if (ch === '\x7f') { // Backspace
@@ -236,10 +245,11 @@ function prompt(message, hidden = false) {
                 }
             };
             process.stdin.on('data', handler);
-        }
-        else {
-            rl.question(message, (answer) => { rl.close(); resolve(answer); });
-        }
+        });
+    }
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+        rl.question(message, (answer) => { rl.close(); resolve(answer); });
     });
 }
 //# sourceMappingURL=auth.js.map

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

@@ -0,0 +1,4 @@
+import { DeviceConnection } from '../../agent/device-connection.js';
+export declare function loadPackDeviceHandlers(conn: DeviceConnection, projectDir: string): Promise<string[]>;
+export declare function handleConnect(projectDir: string): Promise<void>;
+//# sourceMappingURL=connect.d.ts.map

package/dist/cli/commands/connect.js

@@ -0,0 +1,163 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import * as readline from 'node:readline';
+import { DeviceConnection } from '../../agent/device-connection.js';
+import { discoverDeviceHandlers } from '../../marketplace/registry.js';
+function promptYesNo(message) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+        rl.question(message, (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            resolve(normalized === '' || normalized === 'y' || normalized === 'yes');
+        });
+    });
+}
+export async function loadPackDeviceHandlers(conn, projectDir) {
+    const loadedPacks = [];
+    try {
+        const handlers = await discoverDeviceHandlers(projectDir);
+        for (const handler of handlers) {
+            try {
+                const mod = await import(handler.entrypoint);
+                if (typeof mod.register === 'function') {
+                    await mod.register(conn, { projectDir });
+                    loadedPacks.push(handler.packageName);
+                    process.stderr.write(`  \x1b[2m+ ${handler.packageName} handlers\x1b[0m\n`);
+                }
+            }
+            catch (err) {
+                process.stderr.write(`  \x1b[33m⚠\x1b[0m Failed to load handlers from ${handler.packageName}: ${err instanceof Error ? err.message : err}\n`);
+            }
+        }
+    }
+    catch {
+        // Discovery failed — non-fatal
+    }
+    return loadedPacks;
+}
+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)), hasUnfetchedChildren: e.isDirectory() }));
+    });
+    // Load pack device handlers (if any installed packs provide them)
+    const loadedPacks = await loadPackDeviceHandlers(conn, projectDir);
+    // Tell the platform which packs contributed handlers (for auto-install)
+    if (loadedPacks.length > 0) {
+        conn.setPacks(loadedPacks);
+    }
+    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('');
+    // Check if packs need to be installed in the Studio workspace
+    if (loadedPacks.length > 0) {
+        try {
+            const checkRes = await fetch(`${creds.platformUrl}/devices/check-packs`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${creds.token}` },
+                body: JSON.stringify({ packs: loadedPacks }),
+            });
+            if (checkRes.ok) {
+                const { missing } = await checkRes.json();
+                if (missing.length > 0) {
+                    console.log('  The following packs need to be installed in Studio:');
+                    for (const p of missing) {
+                        console.log(`    \x1b[36m${p}\x1b[0m`);
+                    }
+                    console.log('');
+                    const answer = await promptYesNo('  Install now? (Y/n) ');
+                    if (answer) {
+                        process.stderr.write('  Installing...');
+                        const installRes = await fetch(`${creds.platformUrl}/devices/install-packs`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${creds.token}` },
+                            body: JSON.stringify({ packs: missing }),
+                        });
+                        if (installRes.ok) {
+                            const { results } = await installRes.json();
+                            const allOk = results.every(r => r.ok);
+                            if (allOk) {
+                                process.stderr.write(' \x1b[32m✓\x1b[0m\n\n');
+                            }
+                            else {
+                                process.stderr.write(' \x1b[33mpartial\x1b[0m\n');
+                                for (const r of results) {
+                                    if (!r.ok)
+                                        console.log(`    \x1b[31m✗\x1b[0m ${r.pack}: ${r.error}`);
+                                }
+                                console.log('');
+                            }
+                        }
+                        else {
+                            process.stderr.write(' \x1b[31mfailed\x1b[0m\n\n');
+                        }
+                    }
+                    else {
+                        console.log('  \x1b[2mSkipped. Install manually via Studio marketplace.\x1b[0m\n');
+                    }
+                }
+            }
+        }
+        catch {
+            // Check failed — non-fatal, continue connecting
+        }
+    }
+    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