@synergenius/flow-weaver 0.26.7 → 0.27.0

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

@@ -0,0 +1,4 @@
+export declare function formatLimit(used: number, limit: number): string;
+export declare function usageBar(used: number, limit: number, width?: number): string;
+export declare function accountCommand(): Promise<void>;
+//# sourceMappingURL=account.d.ts.map

package/dist/cli/commands/account.js

@@ -0,0 +1,50 @@
+import { requireLogin, fmt, exitWithError } from '../utils/cli-helpers.js';
+export function formatLimit(used, limit) {
+    if (limit === -1)
+        return `${used} (unlimited)`;
+    return `${used} / ${limit}`;
+}
+export function usageBar(used, limit, width = 20) {
+    if (limit === -1)
+        return '\x1b[36m∞\x1b[0m';
+    if (limit <= 0)
+        return '\x1b[2m-\x1b[0m';
+    const ratio = Math.min(used / limit, 1);
+    const filled = Math.round(ratio * width);
+    const empty = width - filled;
+    const color = ratio >= 0.9 ? '\x1b[31m' : ratio >= 0.7 ? '\x1b[33m' : '\x1b[32m';
+    return `${color}${'█'.repeat(filled)}\x1b[2m${'░'.repeat(empty)}\x1b[0m`;
+}
+export async function accountCommand() {
+    const { creds, client } = requireLogin();
+    try {
+        const [user, usage] = await Promise.all([
+            client.getUser(),
+            client.getDetailedUsage().catch(() => null),
+        ]);
+        console.log('');
+        console.log(`  ${fmt.bold(user.name)}`);
+        console.log(`  ${user.email}`);
+        console.log(`  Plan: ${user.plan}`);
+        console.log(`  Platform: ${fmt.dim(creds.platformUrl)}`);
+        if (usage) {
+            console.log('');
+            const rows = [
+                { label: 'Workflows', ...usage.usage.workflows },
+                { label: 'Deployments', ...usage.usage.deployments },
+                { label: 'Executions', ...usage.usage.executions },
+            ];
+            for (const row of rows) {
+                const bar = usageBar(row.used, row.limit);
+                const nums = formatLimit(row.used, row.limit);
+                console.log(`  ${row.label.padEnd(14)} ${bar}  ${nums}`);
+            }
+            console.log(`  ${'Timeout'.padEnd(14)} ${usage.limits.timeoutMs / 1000}s per run`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to fetch account');
+    }
+}
+//# sourceMappingURL=account.js.map

package/dist/cli/commands/ai-credentials.d.ts

@@ -0,0 +1,12 @@
+export declare function aiAddCommand(provider: string, options: {
+    key?: string;
+    label?: string;
+    model?: string;
+    default?: boolean;
+}): Promise<void>;
+export declare function aiListCommand(): Promise<void>;
+export declare function aiRevokeCommand(id: string, options: {
+    force?: boolean;
+}): Promise<void>;
+export declare function aiTestCommand(id: string): Promise<void>;
+//# sourceMappingURL=ai-credentials.d.ts.map

package/dist/cli/commands/ai-credentials.js

@@ -0,0 +1,95 @@
+import { requireLogin, readLine, confirm, fmt, exitWithError } from '../utils/cli-helpers.js';
+const VALID_PROVIDERS = ['anthropic', 'openai'];
+export async function aiAddCommand(provider, options) {
+    const { client } = requireLogin();
+    try {
+        if (!VALID_PROVIDERS.includes(provider)) {
+            throw new Error(`Invalid provider "${provider}". Use: ${VALID_PROVIDERS.join(', ')}`);
+        }
+        // Read key from --key flag or prompt via stdin (non-TTY requires --key)
+        let apiKey = options.key;
+        if (!apiKey) {
+            apiKey = await readLine('  Enter API key: ') ?? undefined;
+            if (!apiKey) {
+                throw new Error('No API key provided. Use --key <key> or run in a terminal.');
+            }
+        }
+        const label = options.label ?? `${provider} key`;
+        const cred = await client.createAiCredential({
+            provider,
+            label,
+            apiKey,
+            defaultModel: options.model,
+            isDefault: options.default,
+        });
+        console.log('');
+        console.log(fmt.ok('Credential added'));
+        console.log('');
+        console.log(`  Provider: ${cred.provider}`);
+        console.log(`  Label:    ${cred.label}`);
+        console.log(`  ID:       ${fmt.dim(cred.id)}`);
+        console.log('');
+        console.log(`  Test it:  fw ai test ${cred.id}`);
+        console.log('');
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to add credential');
+    }
+}
+export async function aiListCommand() {
+    const { client } = requireLogin();
+    try {
+        const creds = await client.listAiCredentials();
+        console.log('');
+        if (creds.length === 0) {
+            console.log('  No AI credentials. Add one with: fw ai add <provider>');
+        }
+        else {
+            console.log(`  ${creds.length} credential${creds.length === 1 ? '' : 's'}:`);
+            console.log('');
+            for (const c of creds) {
+                const def = c.isDefault ? ` ${fmt.yellow('★ default')}` : '';
+                const model = c.defaultModel ? ` ${fmt.dim(`(${c.defaultModel})`)}` : '';
+                console.log(`    ${fmt.cyan(c.provider.padEnd(10))} ${c.label}${model}${def}  ${fmt.dim(c.id)}`);
+            }
+        }
+        console.log('');
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to list credentials');
+    }
+}
+export async function aiRevokeCommand(id, options) {
+    const { client } = requireLogin();
+    if (!options.force) {
+        const confirmed = await confirm('  Are you sure? This cannot be undone. [y/N] ');
+        if (!confirmed) {
+            console.log('  Cancelled.');
+            return;
+        }
+    }
+    try {
+        await client.revokeAiCredential(id);
+        console.log(fmt.ok('Credential revoked'));
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to revoke credential');
+    }
+}
+export async function aiTestCommand(id) {
+    const { client } = requireLogin();
+    try {
+        console.log(`  ${fmt.dim('Testing credential...')}`);
+        const result = await client.testAiCredential(id);
+        if (result.success) {
+            console.log(fmt.ok('Credential is valid'));
+        }
+        else {
+            console.log(fmt.err(`Credential test failed${result.message ? `: ${result.message}` : ''}`));
+        }
+    }
+    catch (err) {
+        exitWithError(err, 'Test failed');
+    }
+}
+//# sourceMappingURL=ai-credentials.js.map

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

@@ -0,0 +1,4 @@
+export declare function apiKeyCreateCommand(name: string): Promise<void>;
+export declare function apiKeyListCommand(): Promise<void>;
+export declare function apiKeyRevokeCommand(idOrPrefix: string): Promise<void>;
+//# sourceMappingURL=apikey.d.ts.map

package/dist/cli/commands/apikey.js

@@ -0,0 +1,64 @@
+import { requireLogin, isUuid, fmt, exitWithError } from '../utils/cli-helpers.js';
+export async function apiKeyCreateCommand(name) {
+    const { client } = requireLogin();
+    try {
+        const apiKey = await client.createApiKey(name);
+        console.log('');
+        console.log(fmt.ok('API key created'));
+        console.log('');
+        console.log(`  Name:   ${apiKey.name}`);
+        console.log(`  Key:    ${fmt.bold(apiKey.key)}`);
+        console.log(`  Prefix: ${apiKey.keyPrefix}`);
+        console.log('');
+        console.log(`  ${fmt.yellow('⚠')} Copy this key now — it cannot be shown again.`);
+        console.log('');
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to create API key');
+    }
+}
+export async function apiKeyListCommand() {
+    const { client } = requireLogin();
+    try {
+        const keys = await client.listApiKeys();
+        console.log('');
+        if (keys.length === 0) {
+            console.log('  No API keys. Create one with: fw apikey create <name>');
+        }
+        else {
+            console.log(`  ${keys.length} API key${keys.length === 1 ? '' : 's'}:`);
+            console.log('');
+            for (const key of keys) {
+                const date = new Date(key.createdAt).toLocaleDateString();
+                console.log(`    ${fmt.cyan(key.keyPrefix + '...')}  ${key.name.padEnd(20)}  ${date}  ${fmt.dim(key.id)}`);
+            }
+        }
+        console.log('');
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to list API keys');
+    }
+}
+export async function apiKeyRevokeCommand(idOrPrefix) {
+    const { client } = requireLogin();
+    try {
+        let id = idOrPrefix;
+        if (!isUuid(idOrPrefix)) {
+            const keys = await client.listApiKeys();
+            const match = keys.filter((k) => k.keyPrefix.startsWith(idOrPrefix) || k.id.startsWith(idOrPrefix));
+            if (match.length === 0) {
+                throw new Error(`No API key matching "${idOrPrefix}"`);
+            }
+            if (match.length > 1) {
+                throw new Error(`Ambiguous: "${idOrPrefix}" matches ${match.length} keys. Use the full ID.`);
+            }
+            id = match[0].id;
+        }
+        await client.revokeApiKey(id);
+        console.log(fmt.ok('API key revoked'));
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to revoke API key');
+    }
+}
+//# sourceMappingURL=apikey.js.map

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

@@ -1,5 +1,6 @@
 export declare function loginCommand(options: {
     email?: string;
+    password?: string;
     apiKey?: string;
     platformUrl?: string;
 }): Promise<void>;

package/dist/cli/commands/auth.js

@@ -1,11 +1,12 @@
 import * as readline from 'node:readline';
 import { loadCredentials, saveCredentials, clearCredentials, getPlatformUrl } from '../config/credentials.js';
 import { PlatformClient } from '../config/platform-client.js';
+import { fmt } from '../utils/cli-helpers.js';
 export async function loginCommand(options) {
     const platformUrl = options.platformUrl ?? getPlatformUrl();
     const displayUrl = platformUrl.replace(/^https?:\/\//, '');
     console.log('');
-    console.log(`  \x1b[1mFlow Weaver\x1b[0m \x1b[2m(${displayUrl})\x1b[0m`);
+    console.log(`  ${fmt.bold('Flow Weaver')} ${fmt.dim(`(${displayUrl})`)}`);
     console.log('');
     // API key mode (for CI/headless)
     if (options.apiKey) {
@@ -14,7 +15,7 @@ export async function loginCommand(options) {
     }
     // Email mode (explicit --email flag)
     if (options.email) {
-        await loginWithEmail(options.email, platformUrl);
+        await loginWithEmail(options.email, platformUrl, options.password);
         return;
     }
     // Default: browser-first device auth
@@ -148,17 +149,17 @@ async function loginWithApiKey(apiKey, platformUrl) {
         userId = user.id;
     }
     catch {
-        console.error('  \x1b[31m✗\x1b[0m Invalid API key');
+        console.error(fmt.err('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(fmt.ok(`Logged in as ${fmt.bold(email)} (${plan} plan)`));
     console.log('');
 }
-async function loginWithEmail(email, platformUrl) {
-    const password = await prompt('  Password: ', true);
+async function loginWithEmail(email, platformUrl, passwordFlag) {
+    const password = passwordFlag ?? await prompt('  Password: ', true);
     try {
         const resp = await fetch(`${platformUrl}/auth/login`, {
             method: 'POST',
@@ -192,28 +193,27 @@ async function loginWithEmail(email, platformUrl) {
 }
 export async function logoutCommand() {
     clearCredentials();
-    console.log('  \x1b[32m✓\x1b[0m Logged out');
+    console.log(fmt.ok('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(fmt.err(`Not logged in. Run: ${fmt.cyan('fw login')}`));
         console.log('');
-        return;
+        process.exit(1);
     }
     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(fmt.ok(`Logged in as ${fmt.bold(creds.email)}`));
     console.log(`  Plan: ${creds.plan}`);
-    console.log(`  Platform: ${creds.platformUrl}`);
+    console.log(`  Platform: ${fmt.dim(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(`    ${fmt.cyan('fw deploy <file>')}         deploy to cloud`);
+    console.log(`    ${fmt.cyan('fw cloud-status')}          see deployments + usage`);
+    console.log(`    ${fmt.cyan('weaver assistant')}          AI with platform credits`);
     console.log('');
 }
 function prompt(message, hidden = false) {

package/dist/cli/commands/deploy.js

@@ -1,31 +1,22 @@
 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';
+import { requireLogin, fmt, exitWithError } from '../utils/cli-helpers.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 { creds, client } = requireLogin();
     const absPath = path.resolve(filePath);
     if (!fs.existsSync(absPath)) {
-        console.error(`  \x1b[31m✗\x1b[0m File not found: ${filePath}`);
-        process.exit(1);
-        return;
+        exitWithError(new Error(`File not found: ${filePath}`), 'File not found');
     }
     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`);
+    console.log(`  ${fmt.dim(`Pushing ${name}...`)}`);
     try {
         const workflow = await client.pushWorkflow(name, source);
-        console.log(`  \x1b[32m✓\x1b[0m Pushed (v${workflow.version})`);
-        console.log(`  \x1b[2mDeploying...\x1b[0m`);
+        console.log(fmt.ok(`Pushed (v${workflow.version})`));
+        console.log(`  ${fmt.dim('Deploying...')}`);
         const deployment = await client.deploy(workflow.slug);
-        console.log(`  \x1b[32m✓\x1b[0m Deployed: ${deployment.slug}`);
+        console.log(fmt.ok(`Deployed: ${deployment.slug}`));
         console.log('');
         console.log(`  Endpoint: ${creds.platformUrl}/run/${deployment.slug}`);
         console.log('');
@@ -37,37 +28,23 @@ export async function deployCommand(filePath, options = {}) {
         console.log('');
     }
     catch (err) {
-        console.error(`  \x1b[31m✗\x1b[0m ${err instanceof Error ? err.message : 'Deploy failed'}`);
-        process.exit(1);
+        exitWithError(err, 'Deploy failed');
     }
 }
 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);
+    const { client } = requireLogin();
     try {
         await client.undeploy(slug);
-        console.log(`  \x1b[32m✓\x1b[0m Undeployed: ${slug}`);
+        console.log(fmt.ok(`Undeployed: ${slug}`));
     }
     catch (err) {
-        console.error(`  \x1b[31m✗\x1b[0m ${err instanceof Error ? err.message : 'Undeploy failed'}`);
+        exitWithError(err, '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);
+    const { creds, client } = requireLogin();
     console.log('');
-    console.log(`  \x1b[1m${creds.email}\x1b[0m \x1b[2m(${creds.plan} plan)\x1b[0m`);
+    console.log(`  ${fmt.bold(creds.email)} ${fmt.dim(`(${creds.plan} plan)`)}`);
     console.log('');
     try {
         const deployments = await client.listDeployments();
@@ -83,7 +60,7 @@ export async function cloudStatusCommand() {
         }
     }
     catch {
-        console.log('  \x1b[33m⚠\x1b[0m Could not fetch deployments');
+        console.log(`  ${fmt.yellow('⚠')} Could not fetch deployments`);
     }
     try {
         const usage = await client.getUsage();

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

@@ -0,0 +1,8 @@
+export declare function orgListCommand(): Promise<void>;
+export declare function orgCreateCommand(name: string): Promise<void>;
+export declare function orgMembersCommand(identifier: string): Promise<void>;
+export declare function orgInviteCommand(identifier: string, email: string, options: {
+    role?: string;
+}): Promise<void>;
+export declare function orgRemoveCommand(identifier: string, userIdentifier: string): Promise<void>;
+//# sourceMappingURL=org.d.ts.map

package/dist/cli/commands/org.js

@@ -0,0 +1,136 @@
+import { requireLogin, isUuid, fmt, exitWithError } from '../utils/cli-helpers.js';
+/**
+ * Resolve an org identifier (UUID, slug, name, or prefix) to an org ID.
+ * Exact slug/name matches take priority over prefix matches.
+ */
+async function resolveOrgId(client, identifier) {
+    if (isUuid(identifier))
+        return identifier;
+    const orgs = await client.listOrgs();
+    // Exact match first (slug or name)
+    const exact = orgs.find((o) => o.slug === identifier || o.name === identifier);
+    if (exact)
+        return exact.id;
+    // Prefix match as fallback
+    const prefixMatches = orgs.filter((o) => o.slug.startsWith(identifier) || o.id.startsWith(identifier));
+    if (prefixMatches.length === 0) {
+        throw new Error(`No organization matching "${identifier}". Run: fw org list`);
+    }
+    if (prefixMatches.length > 1) {
+        throw new Error(`Ambiguous: "${identifier}" matches ${prefixMatches.length} organizations. Use the full slug or ID.`);
+    }
+    return prefixMatches[0].id;
+}
+/**
+ * Resolve a user identifier (email, email prefix, or UUID) to a userId within an org.
+ * Exact email matches take priority over prefix matches.
+ */
+async function resolveUserId(client, orgId, identifier, orgLabel) {
+    if (isUuid(identifier))
+        return identifier;
+    const org = await client.getOrg(orgId);
+    // Exact match first
+    const exact = org.members.find((m) => m.email === identifier);
+    if (exact)
+        return exact.userId;
+    // Prefix match as fallback
+    const prefixMatches = org.members.filter((m) => m.email.startsWith(identifier) || m.userId.startsWith(identifier));
+    if (prefixMatches.length === 0) {
+        throw new Error(`No member matching "${identifier}" in this organization. Run: fw org members ${orgLabel ?? orgId}`);
+    }
+    if (prefixMatches.length > 1) {
+        throw new Error(`Ambiguous: "${identifier}" matches ${prefixMatches.length} members. Use the full email or ID.`);
+    }
+    return prefixMatches[0].userId;
+}
+export async function orgListCommand() {
+    const { client } = requireLogin();
+    try {
+        const orgs = await client.listOrgs();
+        console.log('');
+        if (orgs.length === 0) {
+            console.log('  No organizations. Create one with: fw org create <name>');
+        }
+        else {
+            console.log(`  ${orgs.length} organization${orgs.length === 1 ? '' : 's'}:`);
+            console.log('');
+            for (const org of orgs) {
+                const roleColor = org.role === 'owner' ? '\x1b[33m' : '\x1b[2m';
+                console.log(`    ${fmt.bold(org.name)}  ${fmt.dim(org.slug)}  ${roleColor}${org.role}\x1b[0m`);
+            }
+        }
+        console.log('');
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to list organizations');
+    }
+}
+export async function orgCreateCommand(name) {
+    const { client } = requireLogin();
+    try {
+        const org = await client.createOrg(name);
+        console.log('');
+        console.log(fmt.ok('Organization created'));
+        console.log('');
+        console.log(`  Name: ${org.name}`);
+        console.log(`  Slug: ${org.slug}`);
+        console.log(`  ID:   ${fmt.dim(org.id)}`);
+        console.log('');
+        console.log(`  Invite members: fw org invite ${org.slug} <email>`);
+        console.log('');
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to create organization');
+    }
+}
+export async function orgMembersCommand(identifier) {
+    const { client } = requireLogin();
+    try {
+        const orgId = await resolveOrgId(client, identifier);
+        const org = await client.getOrg(orgId);
+        console.log('');
+        console.log(`  ${fmt.bold(org.name)}`);
+        console.log('');
+        if (org.members.length === 0) {
+            console.log('  No members.');
+        }
+        else {
+            for (const m of org.members) {
+                const roleColor = m.role === 'owner' ? '\x1b[33m' : '\x1b[2m';
+                console.log(`    ${m.email.padEnd(30)} ${m.name.padEnd(20)} ${roleColor}${m.role}\x1b[0m`);
+            }
+        }
+        console.log('');
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to get organization');
+    }
+}
+export async function orgInviteCommand(identifier, email, options) {
+    const { client } = requireLogin();
+    const role = options.role ?? 'editor';
+    try {
+        if (!['editor', 'viewer'].includes(role)) {
+            throw new Error(`Invalid role "${role}". Use: editor, viewer`);
+        }
+        const orgId = await resolveOrgId(client, identifier);
+        await client.inviteOrgMember(orgId, email, role);
+        console.log(fmt.ok(`Invited ${email} as ${role}`));
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to invite member');
+    }
+}
+export async function orgRemoveCommand(identifier, userIdentifier) {
+    const { client } = requireLogin();
+    try {
+        const orgId = await resolveOrgId(client, identifier);
+        const userId = await resolveUserId(client, orgId, userIdentifier, identifier);
+        await client.removeOrgMember(orgId, userId);
+        console.log(fmt.ok('Member removed'));
+    }
+    catch (err) {
+        exitWithError(err, 'Failed to remove member');
+    }
+}
+//# sourceMappingURL=org.js.map

package/dist/cli/config/platform-client.d.ts

@@ -30,6 +30,93 @@ export declare class PlatformClient {
         plan: string;
     }>;
     streamChat(message: string, conversationId?: string): AsyncGenerator<Record<string, unknown>>;
+    createApiKey(name: string): Promise<{
+        id: string;
+        name: string;
+        keyPrefix: string;
+        key: string;
+        createdAt: string;
+    }>;
+    listApiKeys(): Promise<Array<{
+        id: string;
+        name: string;
+        keyPrefix: string;
+        createdAt: string;
+    }>>;
+    revokeApiKey(id: string): Promise<void>;
+    createAiCredential(opts: {
+        provider: string;
+        label: string;
+        apiKey: string;
+        baseUrl?: string;
+        defaultModel?: string;
+        isDefault?: boolean;
+    }): Promise<{
+        id: string;
+        provider: string;
+        label: string;
+        createdAt: string;
+    }>;
+    listAiCredentials(): Promise<Array<{
+        id: string;
+        provider: string;
+        label: string;
+        defaultModel?: string;
+        isDefault: boolean;
+        createdAt: string;
+    }>>;
+    revokeAiCredential(id: string): Promise<void>;
+    testAiCredential(id: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    getDetailedUsage(): Promise<{
+        plan: string;
+        usage: {
+            workflows: {
+                used: number;
+                limit: number;
+            };
+            deployments: {
+                used: number;
+                limit: number;
+            };
+            executions: {
+                used: number;
+                limit: number;
+                period: string;
+            };
+        };
+        limits: {
+            timeoutMs: number;
+        };
+    }>;
+    listOrgs(): Promise<Array<{
+        id: string;
+        name: string;
+        slug: string;
+        role: string;
+        createdAt: string;
+    }>>;
+    createOrg(name: string): Promise<{
+        id: string;
+        name: string;
+        slug: string;
+    }>;
+    getOrg(orgId: string): Promise<{
+        id: string;
+        name: string;
+        slug: string;
+        members: Array<{
+            userId: string;
+            name: string;
+            email: string;
+            role: string;
+            joinedAt: string;
+        }>;
+    }>;
+    inviteOrgMember(orgId: string, email: string, role?: string): Promise<void>;
+    removeOrgMember(orgId: string, userId: string): Promise<void>;
     validate(): Promise<boolean>;
 }
 export declare function createPlatformClient(creds: StoredCredentials): PlatformClient;