runwork 0.4.1 → 0.5.1

package/dist/commands/endpoints.js

@@ -0,0 +1,188 @@
+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';
+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 workspace public endpoints')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name>', '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 endpoints = await client.listEndpoints(workspaceId);
+        if (opts.app) {
+            endpoints = endpoints.filter(e => e.appId === opts.app || e.appName === opts.app);
+        }
+        if (useJson) {
+            jsonOut({ endpoints });
+            return;
+        }
+        if (endpoints.length === 0) {
+            console.log('No endpoints found in this workspace.');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        console.log(`  ${'METHOD'.padEnd(8)} ${'PATH'.padEnd(36)} ${'APP'.padEnd(20)} ${'AUTH'.padEnd(10)} DESCRIPTION`);
+        console.log('  ' + '-'.repeat(90));
+        for (const e of endpoints) {
+            const method = e.method.toUpperCase().padEnd(8);
+            const path = e.endpointPath.padEnd(36);
+            const app = (e.appName || e.appId).padEnd(20);
+            const auth = (e.auth || '').padEnd(10);
+            const desc = truncate(e.description, 40);
+            const mode = e.deploymentMode ? ` [${e.deploymentMode}]` : '';
+            console.log(`  ${method} ${path} ${app} ${auth} ${desc}${mode}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list endpoints:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const callCommand = new Command('call')
+    .description('Call a workspace endpoint directly')
+    .argument('<method>', 'HTTP method (GET, POST, PUT, DELETE, etc.)')
+    .argument('<path>', 'Endpoint path (e.g. /my-endpoint)')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <name>', 'App name or ID (narrows endpoint lookup)')
+    .option('--body <json>', 'Request body as JSON string')
+    .option('--header <header>', 'Request header (format: "Key: Value", repeatable)', (val, prev) => [...prev, val], [])
+    .option('--query <string>', 'Query string to append to the URL (e.g. "foo=bar&baz=1")')
+    .option('--api-key <key>', 'API key for Authorization: Bearer header')
+    .action(async (method, path, 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 endpoints = await client.listEndpoints(workspaceId);
+        if (opts.app) {
+            endpoints = endpoints.filter(e => e.appId === opts.app || e.appName === opts.app);
+        }
+        const targetMethod = method.toUpperCase();
+        const endpoint = endpoints.find(e => e.method.toUpperCase() === targetMethod && e.endpointPath === path);
+        if (!endpoint) {
+            console.error(`Endpoint not found: ${targetMethod} ${path}`);
+            if (endpoints.length > 0) {
+                console.error('\nAvailable endpoints:');
+                for (const e of endpoints) {
+                    console.error(`  ${e.method.toUpperCase().padEnd(8)} ${e.endpointPath}  (${e.appName || e.appId})`);
+                }
+            }
+            else {
+                console.error('No endpoints registered in this workspace.');
+            }
+            process.exit(1);
+        }
+        const appInfo = await client.getApp(endpoint.appId);
+        const appSlug = appInfo.slug;
+        // Build URL: https://{workspaceName}.runwork.ai/{appSlug}/endpoints{path}
+        if (!workspaceName) {
+            console.error('Could not determine workspace name. Provide --workspace with a named workspace.');
+            process.exit(1);
+        }
+        const baseUrl = `https://${workspaceName}.runwork.ai`;
+        let url = `${baseUrl}/${appSlug}/endpoints${path}`;
+        if (opts.query) {
+            url = `${url}?${opts.query}`;
+        }
+        // Build headers
+        const headers = {};
+        if (opts.apiKey) {
+            headers['Authorization'] = `Bearer ${opts.apiKey}`;
+        }
+        for (const h of opts.header) {
+            const colonIndex = h.indexOf(':');
+            if (colonIndex === -1) {
+                console.error(`Invalid header format "${h}" — expected "Key: Value"`);
+                process.exit(1);
+            }
+            const key = h.slice(0, colonIndex).trim();
+            const value = h.slice(colonIndex + 1).trim();
+            headers[key] = value;
+        }
+        // Parse body
+        let body;
+        if (opts.body) {
+            try {
+                // Validate it's valid JSON then re-serialize for consistency
+                const parsed = JSON.parse(opts.body);
+                body = JSON.stringify(parsed);
+                if (!headers['Content-Type']) {
+                    headers['Content-Type'] = 'application/json';
+                }
+            }
+            catch {
+                console.error('Failed to parse --body as JSON. Provide a valid JSON string.');
+                process.exit(1);
+            }
+        }
+        if (useJson) {
+            // Let the caller know what we're calling before making the request
+            process.stderr.write(JSON.stringify({ calling: { method: targetMethod, url } }) + '\n');
+        }
+        else {
+            console.log(`\n${targetMethod} ${url}\n`);
+        }
+        const response = await fetch(url, {
+            method: targetMethod,
+            headers,
+            body,
+        });
+        const contentType = response.headers.get('content-type') || '';
+        const responseText = await response.text();
+        if (useJson) {
+            let responseBody = responseText;
+            if (contentType.includes('application/json')) {
+                try {
+                    responseBody = JSON.parse(responseText);
+                }
+                catch {
+                    // leave as string
+                }
+            }
+            jsonOut({
+                status: response.status,
+                statusText: response.statusText,
+                headers: Object.fromEntries(response.headers.entries()),
+                body: responseBody,
+            });
+            return;
+        }
+        console.log(`Status: ${response.status} ${response.statusText}\n`);
+        if (contentType.includes('application/json')) {
+            try {
+                const parsed = JSON.parse(responseText);
+                console.log(JSON.stringify(parsed, null, 2));
+            }
+            catch {
+                console.log(responseText);
+            }
+        }
+        else {
+            console.log(responseText);
+        }
+    }
+    catch (err) {
+        console.error('Failed to call endpoint:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const endpointsCommand = new Command('endpoints')
+    .alias('routes')
+    .description('Manage and call workspace endpoints')
+    .addCommand(listCommand)
+    .addCommand(callCommand);

package/dist/commands/entities.d.ts

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

package/dist/commands/entities.js

@@ -0,0 +1,198 @@
+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';
+import { promptConfirm } from '../utils/prompt.js';
+import { parseDataInput } from '../utils/data-input.js';
+const listCommand = new Command('list')
+    .description('List entities registered in the workspace')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--app <id>', 'Filter by app name or ID')
+    .option('--preview', 'Show preview-mode entities only')
+    .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 entities = await client.listEntities(workspaceId);
+        if (opts.app) {
+            entities = entities.filter(e => e.appId === opts.app || e.appName === opts.app);
+        }
+        if (opts.preview) {
+            entities = entities.filter(e => e.deploymentMode === 'preview');
+        }
+        if (useJson) {
+            jsonOut({ entities });
+            return;
+        }
+        if (entities.length === 0) {
+            console.log('No entities found in this workspace.');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        console.log(`  ${'Entity'.padEnd(28)} ${'App'.padEnd(24)} ${'Mode'.padEnd(12)}`);
+        console.log('  ' + '-'.repeat(66));
+        for (const e of entities) {
+            console.log(`  ${e.entityName.padEnd(28)} ${e.appName.padEnd(24)} ${(e.deploymentMode ?? '').padEnd(12)}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list entities:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const recordsCommand = new Command('records')
+    .description('List records for an entity')
+    .argument('<entity>', 'Entity name')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--limit <n>', 'Number of records to return', '20')
+    .option('--cursor <cursor>', 'Pagination cursor')
+    .option('--preview', 'Query preview-mode data')
+    .action(async (entity, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        const result = await client.listEntityRecords(workspaceId, entity, {
+            limit: parseInt(opts.limit, 10),
+            cursor: opts.cursor,
+            deploymentMode: opts.preview ? 'preview' : undefined,
+        });
+        if (useJson) {
+            jsonOut(result);
+            return;
+        }
+        if (result.items.length === 0) {
+            console.log(`No records found for entity "${entity}".`);
+            return;
+        }
+        console.log(`\nEntity: ${entity}  (${result.items.length} record(s))\n`);
+        console.log(JSON.stringify(result.items, null, 2));
+        if (result.next) {
+            console.log(`\nNext cursor: ${result.next}`);
+        }
+    }
+    catch (err) {
+        console.error('Failed to list entity records:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const getCommand = new Command('get')
+    .description('Get a single entity record by ID')
+    .argument('<entity>', 'Entity name')
+    .argument('<id>', 'Record ID')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (entity, id, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        const result = await client.getEntityRecord(workspaceId, entity, id);
+        if (useJson) {
+            jsonOut(result);
+            return;
+        }
+        console.log(JSON.stringify(result.item, null, 2));
+    }
+    catch (err) {
+        console.error('Failed to get entity record:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const createCommand = new Command('create')
+    .description('Create a new entity record')
+    .argument('<entity>', 'Entity name')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--data <json>', 'Record data as JSON string, @file.json, or pipe via stdin')
+    .option('--preview', 'Create in preview-mode data store')
+    .action(async (entity, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        const data = await parseDataInput(opts.data);
+        const result = await client.createEntityRecord(workspaceId, entity, data);
+        if (useJson) {
+            jsonOut(result);
+            return;
+        }
+        console.log('Record created:');
+        console.log(JSON.stringify(result.item, null, 2));
+    }
+    catch (err) {
+        console.error('Failed to create entity record:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const updateCommand = new Command('update')
+    .description('Update an existing entity record')
+    .argument('<entity>', 'Entity name')
+    .argument('<id>', 'Record ID')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--data <json>', 'Record data as JSON string, @file.json, or pipe via stdin')
+    .action(async (entity, id, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        const data = await parseDataInput(opts.data);
+        const result = await client.updateEntityRecord(workspaceId, entity, id, data);
+        if (useJson) {
+            jsonOut(result);
+            return;
+        }
+        console.log('Record updated:');
+        console.log(JSON.stringify(result.item, null, 2));
+    }
+    catch (err) {
+        console.error('Failed to update entity record:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const deleteCommand = new Command('delete')
+    .description('Delete an entity record')
+    .argument('<entity>', 'Entity name')
+    .argument('<id>', 'Record ID')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--yes', 'Skip confirmation prompt')
+    .action(async (entity, id, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        if (!opts.yes) {
+            const confirmed = await promptConfirm(`Delete record "${id}" from entity "${entity}"? This cannot be undone.`);
+            if (!confirmed) {
+                console.log('Cancelled.');
+                return;
+            }
+        }
+        const result = await client.deleteEntityRecord(workspaceId, entity, id);
+        if (useJson) {
+            jsonOut(result);
+            return;
+        }
+        console.log(`Record "${id}" deleted from entity "${entity}".`);
+    }
+    catch (err) {
+        console.error('Failed to delete entity record:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const entitiesCommand = new Command('entities')
+    .alias('data')
+    .description('Manage workspace entity data')
+    .addCommand(listCommand)
+    .addCommand(recordsCommand)
+    .addCommand(getCommand)
+    .addCommand(createCommand)
+    .addCommand(updateCommand)
+    .addCommand(deleteCommand);

package/dist/commands/files.d.ts

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

package/dist/commands/files.js

@@ -0,0 +1,192 @@
+import { Command } from 'commander';
+import { writeFileSync, readFileSync } from 'fs';
+import { basename } from 'path';
+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';
+import { promptConfirm } from '../utils/prompt.js';
+function formatSize(bytes) {
+    if (bytes === undefined)
+        return '';
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+}
+const listCommand = new Command('list')
+    .description('List file storage buckets in 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 storages = await client.listFileStorages(workspaceId);
+        if (useJson) {
+            jsonOut({ storages });
+            return;
+        }
+        if (storages.length === 0) {
+            console.log('No file storage buckets found in this workspace.');
+            return;
+        }
+        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
+        console.log(`  ${'Bucket'.padEnd(32)} ${'App'.padEnd(24)} ${'Status'.padEnd(12)} Objects`);
+        console.log('  ' + '-'.repeat(76));
+        for (const s of storages) {
+            const objectCount = s.objectCount !== undefined ? String(s.objectCount) : '-';
+            console.log(`  ${s.bucketName.padEnd(32)} ${(s.appName || '').padEnd(24)} ${s.bucketStatus.padEnd(12)} ${objectCount}`);
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list file storages:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const lsCommand = new Command('ls')
+    .description('List files in a bucket')
+    .argument('<bucket>', 'Bucket name')
+    .argument('[prefix]', 'Key prefix to filter by')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--delimiter <char>', 'Delimiter for hierarchical listing', '/')
+    .action(async (bucket, prefix, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        const data = await client.listBucketFiles(workspaceId, bucket, {
+            prefix,
+            delimiter: opts.delimiter,
+        });
+        if (useJson) {
+            jsonOut({ bucket, prefix, folders: data.folders, files: data.files, truncated: data.truncated });
+            return;
+        }
+        const totalEntries = data.folders.length + data.files.length;
+        if (totalEntries === 0) {
+            console.log(`No files found${prefix ? ` under prefix "${prefix}"` : ''} in bucket "${bucket}".`);
+            return;
+        }
+        for (const folder of data.folders) {
+            console.log(`  ${folder.prefix}`);
+        }
+        for (const file of data.files) {
+            const size = file.size !== undefined ? formatSize(file.size).padStart(10) : '          ';
+            const modified = file.lastModified ? `  ${file.lastModified}` : '';
+            console.log(`  ${size}  ${file.key}${modified}`);
+        }
+        if (data.truncated) {
+            console.log('\n  (results truncated)');
+        }
+        console.log('');
+    }
+    catch (err) {
+        console.error('Failed to list bucket files:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const downloadCommand = new Command('download')
+    .description('Download a file from a bucket')
+    .argument('<bucket>', 'Bucket name')
+    .argument('<key>', 'Object key to download')
+    .argument('[output]', 'Local output path (defaults to basename of key)')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (bucket, key, output, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    const outputPath = output || basename(key);
+    try {
+        const { url } = await client.getPresignedUrl(workspaceId, bucket, { action: 'read', key });
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+        }
+        writeFileSync(outputPath, Buffer.from(await response.arrayBuffer()));
+        if (useJson) {
+            jsonOut({ success: true, bucket, key, outputPath });
+            return;
+        }
+        console.log(`Downloaded "${key}" to "${outputPath}".`);
+    }
+    catch (err) {
+        console.error('Failed to download file:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const uploadCommand = new Command('upload')
+    .description('Upload a local file to a bucket')
+    .argument('<bucket>', 'Bucket name')
+    .argument('<localPath>', 'Local file path to upload')
+    .argument('[key]', 'Object key in bucket (defaults to basename of local path)')
+    .option('--workspace <id>', 'Workspace ID')
+    .action(async (bucket, localPath, key, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    const objectKey = key || basename(localPath);
+    try {
+        const fileBuffer = readFileSync(localPath);
+        const { url } = await client.getPresignedUrl(workspaceId, bucket, { action: 'write', key: objectKey });
+        const response = await fetch(url, { method: 'PUT', body: fileBuffer });
+        if (!response.ok) {
+            throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
+        }
+        if (useJson) {
+            jsonOut({ success: true, bucket, key: objectKey, localPath });
+            return;
+        }
+        console.log(`Uploaded "${localPath}" to "${bucket}/${objectKey}".`);
+    }
+    catch (err) {
+        console.error('Failed to upload file:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const deleteCommand = new Command('delete')
+    .description('Delete a file from a bucket')
+    .argument('<bucket>', 'Bucket name')
+    .argument('<key>', 'Object key to delete')
+    .option('--workspace <id>', 'Workspace ID')
+    .option('--yes', 'Skip confirmation prompt')
+    .action(async (bucket, key, opts, command) => {
+    const useJson = shouldOutputJson(command.optsWithGlobals().json);
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const { workspaceId } = await resolveWorkspace(client, opts);
+    try {
+        if (!opts.yes) {
+            const confirmed = await promptConfirm(`Delete "${key}" from bucket "${bucket}"?`);
+            if (!confirmed) {
+                console.log('Cancelled.');
+                return;
+            }
+        }
+        await client.deleteBucketFile(workspaceId, bucket, key);
+        if (useJson) {
+            jsonOut({ success: true, bucket, key });
+            return;
+        }
+        console.log(`Deleted "${key}" from bucket "${bucket}".`);
+    }
+    catch (err) {
+        console.error('Failed to delete file:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const filesCommand = new Command('files')
+    .description('Manage workspace file storage')
+    .addCommand(listCommand)
+    .addCommand(lsCommand)
+    .addCommand(downloadCommand)
+    .addCommand(uploadCommand)
+    .addCommand(deleteCommand);

package/dist/commands/info.d.ts

@@ -1,2 +1,3 @@
 import { Command } from 'commander';
+export declare function formatSources(sources: string[]): string;
 export declare const infoCommand: Command;