runwork 0.4.1 → 0.5.1

package/dist/api/client.js

@@ -154,4 +154,203 @@ export class ApiClient {
     getGitRemoteUrl(workspaceId, appId) {
         return `${this.baseUrl}/api/git/${workspaceId}/${appId}`;
     }
+    // --- Workspace Chat API (skills & MCP) ---
+    async listWorkspaceSkills(workspaceId) {
+        const res = await this.request(`/api/workspace-chat/${workspaceId}/skills`);
+        return res.data.skills;
+    }
+    async listExternalSkills(workspaceId) {
+        const res = await this.request(`/api/workspace-chat/${workspaceId}/external-skills`);
+        return res.data.skills;
+    }
+    async importExternalSkill(workspaceId, skill) {
+        const res = await this.request(`/api/workspace-chat/${workspaceId}/external-skills`, { method: 'POST', body: JSON.stringify(skill) });
+        return res.data.skill;
+    }
+    async updateExternalSkill(workspaceId, skillId, skill) {
+        const res = await this.request(`/api/workspace-chat/${workspaceId}/external-skills/${skillId}`, { method: 'PUT', body: JSON.stringify(skill) });
+        return res.data.skill;
+    }
+    async getAppSkillContent(workspaceId, appId) {
+        const res = await this.request(`/api/workspace-chat/${workspaceId}/apps/${appId}/skill`);
+        return res.data.skill;
+    }
+    async listMcpServers(workspaceId) {
+        const res = await this.request(`/api/workspace-chat/${workspaceId}/mcp-servers`);
+        return res.data.servers;
+    }
+    async addMcpServer(workspaceId, server) {
+        const res = await this.request(`/api/workspace-chat/${workspaceId}/mcp-servers`, { method: 'POST', body: JSON.stringify(server) });
+        return res.data.server;
+    }
+    async removeMcpServer(workspaceId, serverId) {
+        await this.request(`/api/workspace-chat/${workspaceId}/mcp-servers/${serverId}`, { method: 'DELETE' });
+    }
+    // --- Workspace Registry: Entities ---
+    async listEntities(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/entities`);
+        return res.data.entities;
+    }
+    async listEntityRecords(workspaceId, entityName, opts) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/entities/${encodeURIComponent(entityName)}/list`, {
+            method: 'POST',
+            body: JSON.stringify({
+                limit: opts?.limit,
+                cursor: opts?.cursor,
+                deploymentMode: opts?.deploymentMode,
+            }),
+        });
+        return res.data;
+    }
+    async getEntityRecord(workspaceId, entityName, recordId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/entities/${encodeURIComponent(entityName)}/${encodeURIComponent(recordId)}`);
+        return res.data;
+    }
+    async createEntityRecord(workspaceId, entityName, data) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/entities/${encodeURIComponent(entityName)}`, { method: 'POST', body: JSON.stringify({ data }) });
+        return res.data;
+    }
+    async updateEntityRecord(workspaceId, entityName, recordId, data) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/entities/${encodeURIComponent(entityName)}/${encodeURIComponent(recordId)}`, { method: 'PUT', body: JSON.stringify({ data }) });
+        return res.data;
+    }
+    async deleteEntityRecord(workspaceId, entityName, recordId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/entities/${encodeURIComponent(entityName)}/${encodeURIComponent(recordId)}`, { method: 'DELETE' });
+        return res.data;
+    }
+    // --- Workspace Registry: Workflows ---
+    async listWorkflows(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/workflows?includeStatus=true`);
+        return res.data.workflows;
+    }
+    async triggerWorkflow(workspaceId, opts) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/workflows/trigger`, { method: 'POST', body: JSON.stringify(opts) });
+        return res.data;
+    }
+    async listWorkflowInstances(workspaceId, appId, opts) {
+        const params = new URLSearchParams({ appId });
+        if (opts?.workflowName)
+            params.set('workflowName', opts.workflowName);
+        if (opts?.status)
+            params.set('status', opts.status);
+        if (opts?.limit)
+            params.set('limit', String(opts.limit));
+        const res = await this.request(`/api/workspaces/${workspaceId}/workflows/instances?${params}`);
+        return res.data;
+    }
+    async getWorkflowInstance(workspaceId, instanceId, appId) {
+        const params = appId ? `?appId=${appId}` : '';
+        const res = await this.request(`/api/workspaces/${workspaceId}/workflows/instances/${encodeURIComponent(instanceId)}${params}`);
+        return res.data;
+    }
+    // --- Workspace Registry: Schedules ---
+    async listSchedules(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/schedules?includeStatus=true`);
+        return res.data.schedules;
+    }
+    async triggerSchedule(workspaceId, opts) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/schedules/trigger`, { method: 'POST', body: JSON.stringify(opts) });
+        return res.data;
+    }
+    async getScheduleHistory(workspaceId, appId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/schedules/history?appId=${appId}`);
+        return res.data;
+    }
+    async getScheduleStatus(workspaceId, appId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/schedules/status?appId=${appId}`);
+        return res.data;
+    }
+    async pauseSchedule(workspaceId, scheduleName, appId) {
+        await this.request(`/api/workspaces/${workspaceId}/schedules/${encodeURIComponent(scheduleName)}/pause?appId=${appId}`, { method: 'POST' });
+    }
+    async resumeSchedule(workspaceId, scheduleName, appId) {
+        await this.request(`/api/workspaces/${workspaceId}/schedules/${encodeURIComponent(scheduleName)}/resume?appId=${appId}`, { method: 'POST' });
+    }
+    // --- Workspace Registry: Endpoints ---
+    async listEndpoints(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/endpoints`);
+        return res.data.endpoints;
+    }
+    // --- Workspace Registry: File Storage ---
+    async listFileStorages(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/file-storages`);
+        return res.data.fileStorages;
+    }
+    async listBucketFiles(workspaceId, bucketName, opts) {
+        const params = new URLSearchParams();
+        if (opts?.prefix)
+            params.set('prefix', opts.prefix);
+        if (opts?.delimiter)
+            params.set('delimiter', opts.delimiter);
+        const query = params.toString();
+        const res = await this.request(`/api/workspaces/${workspaceId}/file-storages/${encodeURIComponent(bucketName)}/files${query ? `?${query}` : ''}`);
+        return res.data;
+    }
+    async getPresignedUrl(workspaceId, bucketName, opts) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/file-storages/${encodeURIComponent(bucketName)}/presign`, { method: 'POST', body: JSON.stringify(opts) });
+        return res.data;
+    }
+    async deleteBucketFile(workspaceId, bucketName, key) {
+        await this.request(`/api/workspaces/${workspaceId}/file-storages/${encodeURIComponent(bucketName)}/files?key=${encodeURIComponent(key)}`, { method: 'DELETE' });
+    }
+    // --- Workspace Registry: Components ---
+    async listComponents(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/components`);
+        return res.data.components;
+    }
+    // --- Workspace Registry: API Keys ---
+    async listApiKeys(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/api-keys`);
+        return res.data.apiKeys;
+    }
+    async createApiKey(workspaceId, opts) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/api-keys`, { method: 'POST', body: JSON.stringify(opts) });
+        return res.data;
+    }
+    // --- Workspace Registry: Agents ---
+    async listAgents(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/agents`);
+        return res.data.agents;
+    }
+    async getAgentStatus(workspaceId, agentName, appId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/agents/status`, { method: 'POST', body: JSON.stringify({ agentName, appId }) });
+        return res.data;
+    }
+    async listAgentExecutions(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/agent-executions`);
+        return res.data.executions;
+    }
+    async getAgentExecutionStream(workspaceId, sessionId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/agent-executions/${encodeURIComponent(sessionId)}/stream`);
+        return res.data.stream;
+    }
+    // --- Integrations: Proxy Call ---
+    async callIntegrationProxy(integrationDbId, method, path, opts) {
+        const targetPath = opts?.query ? `${path}?${opts.query}` : path;
+        const url = `${this.baseUrl}/api/proxy/integrations${targetPath}`;
+        const headers = {
+            'X-Workspace-Integration-Id': integrationDbId,
+            ...Object.fromEntries(Object.entries(opts?.headers || {})),
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        if (opts?.body) {
+            headers['Content-Type'] = 'application/json';
+        }
+        const response = await fetch(url, {
+            method,
+            headers,
+            body: opts?.body ? JSON.stringify(opts.body) : undefined,
+        });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`Integration proxy error ${response.status}: ${body}`);
+        }
+        const contentType = response.headers.get('content-type') || '';
+        if (contentType.includes('application/json')) {
+            return response.json();
+        }
+        return response.text();
+    }
 }

package/dist/auth/store.js

@@ -4,6 +4,24 @@ import { homedir } from 'os';
 const RUNWORK_DIR = join(homedir(), '.runwork');
 const CREDENTIALS_FILE = join(RUNWORK_DIR, '.credentials');
 export function getCredentials() {
+    // Support env var auth for sandbox agent sessions
+    // RUNWORK_API_KEY is a JWT proxy token set by the platform when running agents in sandbox
+    if (process.env.RUNWORK_API_KEY) {
+        let baseUrl = 'https://runwork.ai';
+        if (process.env.WORKSPACE_API_URL) {
+            try {
+                baseUrl = new URL(process.env.WORKSPACE_API_URL).origin;
+            }
+            catch { /* use default */ }
+        }
+        return {
+            apiKey: process.env.RUNWORK_API_KEY,
+            email: 'agent@runwork.ai',
+            baseUrl,
+            defaultWorkspaceId: process.env.WORKSPACE_ID,
+            defaultWorkspaceName: undefined,
+        };
+    }
     if (!existsSync(CREDENTIALS_FILE))
         return null;
     try {

package/dist/commands/agents.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const agentsCommand: Command;

package/dist/commands/agents.js

@@ -0,0 +1,160 @@
+import { Command } from 'commander';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { resolveWorkspace, resolveApp } from '../workspace/resolve.js';
+import { shouldOutputJson, jsonOut } from '../utils/output.js';
+function truncate(text, max) {
+    if (!text)
+        return '';
+    const first = text.split('\n')[0];
+    if (first.length <= max)
+        return first;
+    return first.slice(0, max - 3) + '...';
+}
+const listCommand = new Command('list')
+    .description('List agents in workspace')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <id>', 'Filter by app name or ID')
+    .action(async (opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId, workspaceName } = await resolveWorkspace(client, opts);
+    try {
+        let agents = await client.listAgents(workspaceId);
+        if (opts.app) {
+            agents = agents.filter(a => a.appId === opts.app || a.appName === opts.app);
+        }
+        if (useJson) {
+            jsonOut({ agents });
+            return;
+        }
+        if (agents.length === 0) {
+            console.log('No agents found in this workspace.');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        console.log('  ' +
+            'Name'.padEnd(24) +
+            'Type'.padEnd(16) +
+            'App'.padEnd(20) +
+            'Description'.padEnd(42) +
+            'Integrations'.padEnd(20) +
+            'Entities'.padEnd(20) +
+            'Mode');
+        console.log('  ' + '-'.repeat(140));
+        for (const a of agents) {
+            const name = a.agentName.padEnd(24);
+            const type = a.type.padEnd(16);
+            const app = truncate(a.appName, 18).padEnd(20);
+            const desc = truncate(a.description, 40).padEnd(42);
+            const integrations = (a.integrations?.join(', ') || '').padEnd(20);
+            const entities = (a.entities?.join(', ') || '').padEnd(20);
+            const mode = a.deploymentMode || '';
+            console.log(`  ${name}${type}${app}${desc}${integrations}${entities}${mode}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list agents:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const statusCommand = new Command('status')
+    .description('Get status of a specific agent')
+    .argument('<name>', 'Agent name')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <id>', 'App name or ID (required)')
+    .action(async (name, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    const { appId } = await resolveApp(client, workspaceId, opts);
+    try {
+        const status = await client.getAgentStatus(workspaceId, name, appId);
+        if (useJson) {
+            jsonOut({ status });
+            return;
+        }
+        console.log(JSON.stringify(status, null, 2));
+    }
+    catch (err) {
+        console.error('Failed to get agent status:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const executionsCommand = new Command('executions')
+    .description('List agent execution history for workspace')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        const executions = await client.listAgentExecutions(workspaceId);
+        if (useJson) {
+            jsonOut({ executions });
+            return;
+        }
+        if (executions.length === 0) {
+            console.log('No agent executions found.');
+            return;
+        }
+        console.log('  ' +
+            'Session ID'.padEnd(36) +
+            'Agent'.padEnd(22) +
+            'App'.padEnd(22) +
+            'Prompt'.padEnd(52) +
+            'Status'.padEnd(12) +
+            'Duration'.padEnd(12) +
+            'Usage');
+        console.log('  ' + '-'.repeat(160));
+        for (const e of executions) {
+            const sessionId = e.sessionId.padEnd(36);
+            const agent = truncate(e.agentName, 20).padEnd(22);
+            const app = truncate(e.appId, 20).padEnd(22);
+            const prompt = truncate(e.prompt, 50).padEnd(52);
+            const status = e.status.padEnd(12);
+            const duration = e.durationMs != null ? `${e.durationMs}ms` : '';
+            const usage = e.usage
+                ? `${e.usage.inputTokens}/${e.usage.outputTokens}`
+                : '';
+            console.log(`  ${sessionId}${agent}${app}${prompt}${status}${duration.padEnd(12)}${usage}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list agent executions:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const executionCommand = new Command('execution')
+    .description('Get execution stream for a specific session')
+    .argument('<sessionId>', 'Session ID')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (sessionId, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        const stream = await client.getAgentExecutionStream(workspaceId, sessionId);
+        if (useJson) {
+            jsonOut({ stream });
+            return;
+        }
+        process.stdout.write(stream);
+    }
+    catch (err) {
+        console.error('Failed to get agent execution stream:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const agentsCommand = new Command('agents')
+    .description('Manage workspace agents and execution history')
+    .addCommand(listCommand)
+    .addCommand(statusCommand)
+    .addCommand(executionsCommand)
+    .addCommand(executionCommand);

package/dist/commands/api-keys.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const apiKeysCommand: Command;

package/dist/commands/api-keys.js

@@ -0,0 +1,95 @@
+import { Command } from 'commander';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { resolveWorkspace, resolveApp } from '../workspace/resolve.js';
+import { shouldOutputJson, jsonOut } from '../utils/output.js';
+import { promptInput } from '../utils/prompt.js';
+const listCommand = new Command('list')
+    .description('List API keys for the workspace')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId, workspaceName } = await resolveWorkspace(client, opts);
+    try {
+        const apiKeys = await client.listApiKeys(workspaceId);
+        if (useJson) {
+            jsonOut({ apiKeys });
+            return;
+        }
+        if (apiKeys.length === 0) {
+            console.log('No API keys found in this workspace.');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        console.log(`  ${'Name'.padEnd(24)} ${'Key Prefix'.padEnd(16)} ${'App'.padEnd(20)} ${'Active'.padEnd(8)} ${'Requests'.padEnd(10)} ${'Last Used'.padEnd(22)} Created`);
+        console.log('  ' + '-'.repeat(112));
+        for (const k of apiKeys) {
+            const prefix = `${k.keyPrefix}...`;
+            const appLabel = k.appId ? k.appId : 'all';
+            const active = k.isActive ? 'yes' : 'no';
+            const requests = k.requestCount !== undefined ? String(k.requestCount) : '-';
+            const lastUsed = k.lastUsedAt ? new Date(k.lastUsedAt).toLocaleString() : '-';
+            const created = new Date(k.createdAt).toLocaleString();
+            console.log(`  ${k.name.padEnd(24)} ${prefix.padEnd(16)} ${appLabel.padEnd(20)} ${active.padEnd(8)} ${requests.padEnd(10)} ${lastUsed.padEnd(22)} ${created}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list API keys:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const createCommand = new Command('create')
+    .description('Create a new API key')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--name <name>', 'API key name')
+    .option('--app <id>', 'Restrict key to a specific app (name or ID)')
+    .option('--scopes <scopes>', 'Comma-separated list of scopes')
+    .action(async (opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    let name = opts.name ?? '';
+    if (!name) {
+        if (process.stdout.isTTY) {
+            name = await promptInput('API key name:');
+            if (!name) {
+                console.error('API key name is required.');
+                process.exit(1);
+            }
+        }
+        else {
+            console.error('API key name is required. Use --name flag.');
+            process.exit(1);
+        }
+    }
+    let appId;
+    if (opts.app) {
+        const resolved = await resolveApp(client, workspaceId, { app: opts.app });
+        appId = resolved.appId;
+    }
+    const scopes = opts.scopes
+        ? opts.scopes.split(',').map((s) => s.trim()).filter(Boolean)
+        : undefined;
+    try {
+        const result = await client.createApiKey(workspaceId, { name, appId, scopes });
+        if (useJson) {
+            jsonOut({ apiKey: result });
+            return;
+        }
+        console.log(`\nAPI key created: ${result.name}`);
+        console.log(`\n  Key: ${result.key}`);
+        console.log(`\n  WARNING: Save this key now - it cannot be retrieved again.\n`);
+    }
+    catch (err) {
+        console.error('Failed to create API key:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const apiKeysCommand = new Command('api-keys')
+    .description('Manage workspace API keys')
+    .addCommand(listCommand)
+    .addCommand(createCommand);

package/dist/commands/apps.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const appsCommand: Command;

package/dist/commands/apps.js

@@ -0,0 +1,82 @@
+import { Command } from 'commander';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { resolveWorkspace, resolveApp } from '../workspace/resolve.js';
+import { shouldOutputJson, jsonOut } from '../utils/output.js';
+import { fetchAppInfo, printAppInfo } from '../utils/app-info.js';
+import { runCreateFlow } from './init.js';
+const listCommand = new Command('list')
+    .description('List apps in workspace')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId, workspaceName } = await resolveWorkspace(client, opts);
+    try {
+        const apps = await client.listApps(workspaceId);
+        if (useJson) {
+            jsonOut({ apps });
+            return;
+        }
+        if (apps.length === 0) {
+            console.log('No apps in this workspace.');
+            console.log('Create one with: runwork create <name>');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        console.log(`  ${'Name'.padEnd(28)} ${'ID'.padEnd(38)} Status`);
+        console.log('  ' + '-'.repeat(80));
+        for (const app of apps) {
+            console.log(`  ${(app.name || '').padEnd(28)} ${app.id}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list apps:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const createCommand = new Command('create')
+    .description('Create a new Runwork app')
+    .argument('[name]', 'App name')
+    .action(async (name) => {
+    await runCreateFlow(name);
+});
+const infoCommand = new Command('info')
+    .description('Show detailed app info, preview status, and registries')
+    .argument('[app]', 'App ID, name, or slug')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (appArg, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId, workspaceName } = await resolveWorkspace(client, opts);
+    const { appId, appName } = await resolveApp(client, workspaceId, { app: appArg });
+    let appSlug = appName;
+    try {
+        const appData = await client.getApp(appId);
+        appSlug = appData.slug || appName;
+    }
+    catch {
+        // Fall back to appName as slug
+    }
+    const data = await fetchAppInfo(client, {
+        appId,
+        appName,
+        appSlug,
+        workspaceId,
+        workspaceName,
+        baseUrl: credentials.baseUrl || 'https://runwork.ai',
+    });
+    if (useJson) {
+        jsonOut(data);
+        return;
+    }
+    printAppInfo(data);
+});
+export const appsCommand = new Command('apps')
+    .description('Manage workspace apps')
+    .addCommand(listCommand)
+    .addCommand(createCommand)
+    .addCommand(infoCommand);

package/dist/commands/components.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const componentsCommand: Command;

package/dist/commands/components.js

@@ -0,0 +1,43 @@
+import { Command } from 'commander';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { resolveWorkspace } from '../workspace/resolve.js';
+import { shouldOutputJson, jsonOut } from '../utils/output.js';
+const listCommand = new Command('list')
+    .description('List components registered in the workspace')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <id>', 'Filter by app name or ID')
+    .action(async (opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId, workspaceName } = await resolveWorkspace(client, opts);
+    try {
+        let components = await client.listComponents(workspaceId);
+        if (opts.app) {
+            components = components.filter(c => c.appId === opts.app || c.appName === opts.app);
+        }
+        if (useJson) {
+            jsonOut({ components });
+            return;
+        }
+        if (components.length === 0) {
+            console.log('No components found in this workspace.');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        console.log(`  ${'Component'.padEnd(28)} ${'App'.padEnd(24)} ${'Mode'.padEnd(12)}`);
+        console.log('  ' + '-'.repeat(66));
+        for (const c of components) {
+            console.log(`  ${c.componentName.padEnd(28)} ${c.appName.padEnd(24)} ${(c.deploymentMode ?? '').padEnd(12)}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list components:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const componentsCommand = new Command('components')
+    .description('List workspace components')
+    .addCommand(listCommand);

package/dist/commands/endpoints.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const endpointsCommand: Command;