@synergenius/flow-weaver 0.22.8 → 0.22.10

package/dist/agent/index.d.ts

@@ -2,13 +2,17 @@
  * @synergenius/flow-weaver/agent
  *
  * Provider-agnostic agent loop with MCP bridge for tool execution.
- * Two built-in providers: Anthropic API (raw fetch) and Claude CLI.
+ * Built-in providers: Anthropic API, Claude CLI, OpenAI-compatible (GPT-4o, Groq, Ollama, etc).
  */
 export type { StreamEvent, AgentMessage, AgentProvider, ToolDefinition, ToolExecutor, ToolEvent, McpBridge, AgentLoopOptions, AgentLoopResult, StreamOptions, SpawnFn, ClaudeCliProviderOptions, CliSessionOptions, Logger, } from './types.js';
 export { runAgentLoop } from './agent-loop.js';
 export { AnthropicProvider, createAnthropicProvider } from './providers/anthropic.js';
 export type { AnthropicProviderOptions } from './providers/anthropic.js';
 export { ClaudeCliProvider, createClaudeCliProvider } from './providers/claude-cli.js';
+export { OpenAICompatProvider, createOpenAICompatProvider } from './providers/openai-compat.js';
+export type { OpenAICompatProviderOptions } from './providers/openai-compat.js';
+export { PlatformProvider, createPlatformProvider } from './providers/platform.js';
+export type { PlatformProviderOptions } from './providers/platform.js';
 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';

package/dist/agent/index.js

@@ -2,13 +2,15 @@
  * @synergenius/flow-weaver/agent
  *
  * Provider-agnostic agent loop with MCP bridge for tool execution.
- * Two built-in providers: Anthropic API (raw fetch) and Claude CLI.
+ * Built-in providers: Anthropic API, Claude CLI, OpenAI-compatible (GPT-4o, Groq, Ollama, etc).
  */
 // Agent loop
 export { runAgentLoop } from './agent-loop.js';
 // Providers
 export { AnthropicProvider, createAnthropicProvider } from './providers/anthropic.js';
 export { ClaudeCliProvider, createClaudeCliProvider } from './providers/claude-cli.js';
+export { OpenAICompatProvider, createOpenAICompatProvider } from './providers/openai-compat.js';
+export { PlatformProvider, createPlatformProvider } from './providers/platform.js';
 // MCP bridge
 export { createMcpBridge } from './mcp-bridge.js';
 // CLI session (warm persistent sessions)

package/dist/agent/providers/openai-compat.d.ts

@@ -0,0 +1,25 @@
+/**
+ * OpenAI-compatible API provider — works with any service that speaks
+ * the OpenAI chat completions API: OpenAI, Groq, Together, Ollama, etc.
+ *
+ * No SDK dependency. Uses only Node.js native fetch + SSE parsing.
+ * Converts OpenAI's delta format to the canonical StreamEvent union.
+ */
+import type { AgentProvider, AgentMessage, ToolDefinition, StreamEvent, StreamOptions } from '../types.js';
+export interface OpenAICompatProviderOptions {
+    apiKey: string;
+    model?: string;
+    maxTokens?: number;
+    /** Base URL for the API (default: https://api.openai.com). Include /v1 if needed. */
+    baseUrl?: string;
+}
+export declare class OpenAICompatProvider implements AgentProvider {
+    private apiKey;
+    private model;
+    private maxTokens;
+    private baseUrl;
+    constructor(options: OpenAICompatProviderOptions);
+    stream(messages: AgentMessage[], tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
+}
+export declare function createOpenAICompatProvider(options: OpenAICompatProviderOptions): OpenAICompatProvider;
+//# sourceMappingURL=openai-compat.d.ts.map

package/dist/agent/providers/openai-compat.js

@@ -0,0 +1,204 @@
+/**
+ * OpenAI-compatible API provider — works with any service that speaks
+ * the OpenAI chat completions API: OpenAI, Groq, Together, Ollama, etc.
+ *
+ * No SDK dependency. Uses only Node.js native fetch + SSE parsing.
+ * Converts OpenAI's delta format to the canonical StreamEvent union.
+ */
+export class OpenAICompatProvider {
+    apiKey;
+    model;
+    maxTokens;
+    baseUrl;
+    constructor(options) {
+        if (!options.apiKey) {
+            throw new Error('OpenAICompatProvider requires an API key');
+        }
+        this.apiKey = options.apiKey;
+        this.model = options.model ?? 'gpt-4o';
+        this.maxTokens = options.maxTokens ?? 4096;
+        this.baseUrl = (options.baseUrl ?? 'https://api.openai.com').replace(/\/+$/, '');
+    }
+    async *stream(messages, tools, options) {
+        const model = options?.model ?? this.model;
+        const maxTokens = options?.maxTokens ?? this.maxTokens;
+        // Build OpenAI-format messages
+        const apiMessages = messages.map((m) => formatMessage(m));
+        // Build OpenAI-format tools
+        const apiTools = tools.length > 0
+            ? tools.map((t) => ({
+                type: 'function',
+                function: {
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.inputSchema,
+                },
+            }))
+            : undefined;
+        const body = {
+            model,
+            messages: [
+                ...(options?.systemPrompt ? [{ role: 'system', content: options.systemPrompt }] : []),
+                ...apiMessages,
+            ],
+            max_tokens: maxTokens,
+            stream: true,
+        };
+        if (apiTools && apiTools.length > 0) {
+            body.tools = apiTools;
+        }
+        // Determine the completions endpoint
+        const url = this.baseUrl.includes('/v1/')
+            ? `${this.baseUrl}chat/completions`
+            : `${this.baseUrl}/v1/chat/completions`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify(body),
+            signal: options?.signal,
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => '');
+            yield { type: 'text_delta', text: `OpenAI API error ${response.status}: ${errText.slice(0, 300)}` };
+            yield { type: 'message_stop', finishReason: 'error' };
+            return;
+        }
+        if (!response.body) {
+            yield { type: 'message_stop', finishReason: 'error' };
+            return;
+        }
+        // Parse SSE stream
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let hasToolCalls = false;
+        // Track active tool calls (OpenAI sends incremental deltas by index)
+        const activeToolCalls = new Map();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const data = line.slice(6).trim();
+                    if (data === '[DONE]') {
+                        // Flush any pending tool calls
+                        for (const [, tc] of activeToolCalls) {
+                            let args = {};
+                            try {
+                                args = JSON.parse(tc.argsJson);
+                            }
+                            catch { /* malformed */ }
+                            yield { type: 'tool_use_end', id: tc.id, arguments: args };
+                        }
+                        yield { type: 'message_stop', finishReason: hasToolCalls ? 'tool_calls' : 'stop' };
+                        return;
+                    }
+                    let parsed;
+                    try {
+                        parsed = JSON.parse(data);
+                    }
+                    catch {
+                        continue;
+                    }
+                    // Extract usage if present
+                    if (parsed.usage) {
+                        const usage = parsed.usage;
+                        yield {
+                            type: 'usage',
+                            promptTokens: usage.prompt_tokens ?? 0,
+                            completionTokens: usage.completion_tokens ?? 0,
+                        };
+                    }
+                    const choices = parsed.choices;
+                    if (!choices || choices.length === 0)
+                        continue;
+                    const choice = choices[0];
+                    const delta = choice.delta;
+                    if (!delta)
+                        continue;
+                    // Text content
+                    if (delta.content && typeof delta.content === 'string') {
+                        yield { type: 'text_delta', text: delta.content };
+                    }
+                    // Tool calls
+                    const toolCalls = delta.tool_calls;
+                    if (toolCalls) {
+                        for (const tc of toolCalls) {
+                            const index = tc.index ?? 0;
+                            const fn = tc.function;
+                            if (tc.id) {
+                                // New tool call
+                                hasToolCalls = true;
+                                const name = fn?.name ? String(fn.name) : 'unknown';
+                                activeToolCalls.set(index, { id: String(tc.id), name, argsJson: '' });
+                                yield { type: 'tool_use_start', id: String(tc.id), name };
+                            }
+                            // Accumulate function arguments
+                            if (fn?.arguments && typeof fn.arguments === 'string') {
+                                const existing = activeToolCalls.get(index);
+                                if (existing) {
+                                    existing.argsJson += fn.arguments;
+                                    yield { type: 'tool_use_delta', id: existing.id, partialJson: fn.arguments };
+                                }
+                            }
+                        }
+                    }
+                    // Finish reason
+                    if (choice.finish_reason === 'tool_calls') {
+                        hasToolCalls = true;
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        // If we got here without [DONE], flush
+        for (const [, tc] of activeToolCalls) {
+            let args = {};
+            try {
+                args = JSON.parse(tc.argsJson);
+            }
+            catch { /* malformed */ }
+            yield { type: 'tool_use_end', id: tc.id, arguments: args };
+        }
+        yield { type: 'message_stop', finishReason: hasToolCalls ? 'tool_calls' : 'stop' };
+    }
+}
+function formatMessage(m) {
+    if (m.role === 'tool') {
+        return {
+            role: 'tool',
+            tool_call_id: m.toolCallId,
+            content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+        };
+    }
+    if (m.role === 'assistant' && m.toolCalls?.length) {
+        return {
+            role: 'assistant',
+            content: typeof m.content === 'string' && m.content ? m.content : null,
+            tool_calls: m.toolCalls.map((tc) => ({
+                id: tc.id,
+                type: 'function',
+                function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
+            })),
+        };
+    }
+    return {
+        role: m.role,
+        content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+    };
+}
+export function createOpenAICompatProvider(options) {
+    return new OpenAICompatProvider(options);
+}
+//# sourceMappingURL=openai-compat.js.map

package/dist/agent/providers/platform.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Platform AI provider — routes AI calls through the Flow Weaver platform.
+ * Uses the platform's AI credits, no local API key needed.
+ * Connects to POST /ai-chat/stream and parses SSE events.
+ */
+import type { AgentProvider, AgentMessage, ToolDefinition, StreamEvent, StreamOptions } from '../types.js';
+export interface PlatformProviderOptions {
+    /** JWT token or API key for platform auth */
+    token: string;
+    /** Platform base URL */
+    platformUrl: string;
+    /** Model override (optional — platform selects default) */
+    model?: string;
+}
+export declare class PlatformProvider implements AgentProvider {
+    private token;
+    private baseUrl;
+    private model;
+    constructor(options: PlatformProviderOptions);
+    stream(messages: AgentMessage[], _tools: ToolDefinition[], options?: StreamOptions): AsyncGenerator<StreamEvent>;
+}
+export declare function createPlatformProvider(options: PlatformProviderOptions): PlatformProvider;
+//# sourceMappingURL=platform.d.ts.map

package/dist/agent/providers/platform.js

@@ -0,0 +1,130 @@
+/**
+ * Platform AI provider — routes AI calls through the Flow Weaver platform.
+ * Uses the platform's AI credits, no local API key needed.
+ * Connects to POST /ai-chat/stream and parses SSE events.
+ */
+export class PlatformProvider {
+    token;
+    baseUrl;
+    model;
+    constructor(options) {
+        if (!options.token)
+            throw new Error('PlatformProvider requires a token');
+        if (!options.platformUrl)
+            throw new Error('PlatformProvider requires a platformUrl');
+        this.token = options.token;
+        this.baseUrl = options.platformUrl.replace(/\/+$/, '');
+        this.model = options.model;
+    }
+    async *stream(messages, _tools, options) {
+        // Format the last user message as the prompt
+        // The platform's agent loop handles tools internally
+        const lastUserMsg = [...messages].reverse().find(m => m.role === 'user');
+        const message = lastUserMsg
+            ? (typeof lastUserMsg.content === 'string' ? lastUserMsg.content : JSON.stringify(lastUserMsg.content))
+            : '';
+        if (!message) {
+            yield { type: 'message_stop', finishReason: 'stop' };
+            return;
+        }
+        const isApiKey = this.token.startsWith('fw_');
+        const headers = {
+            'Content-Type': 'application/json',
+            ...(isApiKey
+                ? { 'X-API-Key': this.token }
+                : { Authorization: `Bearer ${this.token}` }),
+        };
+        const body = { message };
+        if (options?.systemPrompt) {
+            // Platform doesn't accept system prompt directly via API — embed in message
+            body.message = `[System context: ${options.systemPrompt.slice(0, 2000)}]\n\n${message}`;
+        }
+        const response = await fetch(`${this.baseUrl}/ai-chat/stream`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(body),
+            signal: options?.signal,
+        });
+        if (!response.ok) {
+            const errText = await response.text().catch(() => '');
+            yield { type: 'text_delta', text: `Platform error ${response.status}: ${errText.slice(0, 300)}` };
+            yield { type: 'message_stop', finishReason: 'error' };
+            return;
+        }
+        if (!response.body) {
+            yield { type: 'message_stop', finishReason: 'error' };
+            return;
+        }
+        // Parse SSE stream from platform
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    let event;
+                    try {
+                        event = JSON.parse(line.slice(6));
+                    }
+                    catch {
+                        continue;
+                    }
+                    // Map platform SSE events to canonical StreamEvent
+                    switch (event.type) {
+                        case 'text_delta':
+                            yield { type: 'text_delta', text: String(event.content ?? '') };
+                            break;
+                        case 'thinking_delta':
+                            yield { type: 'thinking_delta', text: String(event.content ?? '') };
+                            break;
+                        case 'tool_call_start':
+                            yield {
+                                type: 'tool_use_start',
+                                id: String(event.toolCallId ?? ''),
+                                name: String(event.name ?? ''),
+                            };
+                            break;
+                        case 'tool_call_result':
+                            yield {
+                                type: 'tool_result',
+                                id: String(event.toolCallId ?? ''),
+                                result: String(event.result ?? ''),
+                                isError: !!event.isError,
+                            };
+                            break;
+                        case 'usage':
+                            yield {
+                                type: 'usage',
+                                promptTokens: event.promptTokens ?? 0,
+                                completionTokens: event.completionTokens ?? 0,
+                            };
+                            break;
+                        case 'done':
+                            yield { type: 'message_stop', finishReason: 'stop' };
+                            return;
+                        case 'error':
+                            yield { type: 'text_delta', text: `Error: ${event.message ?? 'Unknown error'}` };
+                            yield { type: 'message_stop', finishReason: 'error' };
+                            return;
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+        yield { type: 'message_stop', finishReason: 'stop' };
+    }
+}
+export function createPlatformProvider(options) {
+    return new PlatformProvider(options);
+}
+//# sourceMappingURL=platform.js.map

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

@@ -0,0 +1,8 @@
+export declare function loginCommand(options: {
+    email?: string;
+    apiKey?: string;
+    platformUrl?: string;
+}): Promise<void>;
+export declare function logoutCommand(): Promise<void>;
+export declare function authStatusCommand(): Promise<void>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/cli/commands/auth.js

@@ -0,0 +1,137 @@
+import * as readline from 'node:readline';
+import { loadCredentials, saveCredentials, clearCredentials, getPlatformUrl } from '../config/credentials.js';
+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('');
+    // Validate platform reachable
+    try {
+        const resp = await fetch(`${platformUrl}/ready`);
+        if (!resp.ok)
+            throw new Error();
+    }
+    catch {
+        console.error('  \x1b[31m✗\x1b[0m Cannot connect to platform');
+        console.error(`    Check: ${platformUrl}`);
+        process.exit(1);
+    }
+    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;
+        }
+    }
+    else {
+        // Email/password auth
+        email = options.email ?? await prompt('  Email: ');
+        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();
+            token = data.token;
+            email = data.user.email;
+            plan = data.user.plan;
+            userId = data.user.id;
+        }
+        catch (err) {
+            console.error(`\n  \x1b[31m✗\x1b[0m ${err instanceof Error ? err.message : 'Login failed'}`);
+            process.exit(1);
+            return;
+        }
+    }
+    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('');
+    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('');
+}
+export async function logoutCommand() {
+    clearCredentials();
+    console.log('  \x1b[32m✓\x1b[0m Logged out');
+}
+export async function authStatusCommand() {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.log('');
+        console.log('  Not logged in.');
+        console.log('  Run: \x1b[36mfw login\x1b[0m');
+        console.log('');
+        return;
+    }
+    const expiresIn = Math.floor((creds.expiresAt - Date.now()) / 1000 / 60 / 60);
+    console.log('');
+    console.log(`  \x1b[32m✓\x1b[0m Logged in as \x1b[1m${creds.email}\x1b[0m`);
+    console.log(`  Plan: ${creds.plan}`);
+    console.log(`  Platform: ${creds.platformUrl}`);
+    console.log(`  Token expires in: ${expiresIn}h`);
+    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
+            process.stderr.write(message);
+            process.stdin.setRawMode(true);
+            let input = '';
+            const handler = (key) => {
+                const ch = key.toString();
+                if (ch === '\r' || ch === '\n') {
+                    process.stdin.setRawMode(false);
+                    process.stdin.removeListener('data', handler);
+                    process.stderr.write('\n');
+                    rl.close();
+                    resolve(input);
+                }
+                else if (ch === '\x03') { // Ctrl+C
+                    process.exit(1);
+                }
+                else if (ch === '\x7f') { // Backspace
+                    input = input.slice(0, -1);
+                }
+                else {
+                    input += ch;
+                }
+            };
+            process.stdin.on('data', handler);
+        }
+        else {
+            rl.question(message, (answer) => { rl.close(); resolve(answer); });
+        }
+    });
+}
+//# sourceMappingURL=auth.js.map

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

@@ -0,0 +1,6 @@
+export declare function deployCommand(filePath: string, options?: {
+    name?: string;
+}): Promise<void>;
+export declare function undeployCommand(slug: string): Promise<void>;
+export declare function cloudStatusCommand(): Promise<void>;
+//# sourceMappingURL=deploy.d.ts.map

package/dist/cli/commands/deploy.js

@@ -0,0 +1,97 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { loadCredentials } from '../config/credentials.js';
+import { PlatformClient } from '../config/platform-client.js';
+export async function deployCommand(filePath, options = {}) {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.error('  \x1b[31m✗\x1b[0m Not logged in. Run: fw login');
+        process.exit(1);
+        return;
+    }
+    const absPath = path.resolve(filePath);
+    if (!fs.existsSync(absPath)) {
+        console.error(`  \x1b[31m✗\x1b[0m File not found: ${filePath}`);
+        process.exit(1);
+        return;
+    }
+    const source = fs.readFileSync(absPath, 'utf-8');
+    const name = options.name ?? path.basename(filePath, path.extname(filePath));
+    const client = new PlatformClient(creds);
+    console.log('');
+    console.log(`  \x1b[2mPushing ${name}...\x1b[0m`);
+    try {
+        const workflow = await client.pushWorkflow(name, source);
+        console.log(`  \x1b[32m✓\x1b[0m Pushed (v${workflow.version})`);
+        console.log(`  \x1b[2mDeploying...\x1b[0m`);
+        const deployment = await client.deploy(workflow.slug);
+        console.log(`  \x1b[32m✓\x1b[0m Deployed: ${deployment.slug}`);
+        console.log('');
+        console.log(`  Endpoint: ${creds.platformUrl}/run/${deployment.slug}`);
+        console.log('');
+        console.log('  Test it:');
+        console.log(`    curl -X POST ${creds.platformUrl}/run/${deployment.slug} \\`);
+        console.log(`      -H "X-API-Key: <your-api-key>" \\`);
+        console.log(`      -H "Content-Type: application/json" \\`);
+        console.log(`      -d '{"input": "hello"}'`);
+        console.log('');
+    }
+    catch (err) {
+        console.error(`  \x1b[31m✗\x1b[0m ${err instanceof Error ? err.message : 'Deploy failed'}`);
+        process.exit(1);
+    }
+}
+export async function undeployCommand(slug) {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.error('  \x1b[31m✗\x1b[0m Not logged in.');
+        process.exit(1);
+        return;
+    }
+    const client = new PlatformClient(creds);
+    try {
+        await client.undeploy(slug);
+        console.log(`  \x1b[32m✓\x1b[0m Undeployed: ${slug}`);
+    }
+    catch (err) {
+        console.error(`  \x1b[31m✗\x1b[0m ${err instanceof Error ? err.message : 'Undeploy failed'}`);
+    }
+}
+export async function cloudStatusCommand() {
+    const creds = loadCredentials();
+    if (!creds) {
+        console.log('');
+        console.log('  Not logged in. Run: \x1b[36mfw login\x1b[0m');
+        console.log('');
+        return;
+    }
+    const client = new PlatformClient(creds);
+    console.log('');
+    console.log(`  \x1b[1m${creds.email}\x1b[0m \x1b[2m(${creds.plan} plan)\x1b[0m`);
+    console.log('');
+    try {
+        const deployments = await client.listDeployments();
+        if (deployments.length === 0) {
+            console.log('  No deployments.');
+        }
+        else {
+            console.log('  Deployments:');
+            for (const d of deployments) {
+                const icon = d.status === 'active' ? '\x1b[32m●\x1b[0m' : '\x1b[33m○\x1b[0m';
+                console.log(`    ${icon} ${d.slug.padEnd(25)} ${d.status}`);
+            }
+        }
+    }
+    catch {
+        console.log('  \x1b[33m⚠\x1b[0m Could not fetch deployments');
+    }
+    try {
+        const usage = await client.getUsage();
+        console.log('');
+        console.log(`  AI Credits: ${usage.aiCalls} calls this month`);
+        console.log(`  Executions: ${usage.executions} this month`);
+    }
+    catch { /* usage not available */ }
+    console.log('');
+}
+//# sourceMappingURL=deploy.js.map