@synergenius/flow-weaver 0.23.0 → 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/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