runwork 0.2.0 → 0.2.5

package/LICENSE

@@ -1,21 +1,15 @@
-MIT License
+Copyright (c) 2025-2026 Runwork All rights reserved.
 
-Copyright (c) 2025 Runwork
+This software and associated documentation files (the "Software") are the
+proprietary and confidential property of Runwork
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+No part of the Software may be copied, modified, distributed, sublicensed,
+sold, or otherwise made available to any third party without the prior
+written consent of Runwork
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+You may use the Software solely as a tool to interact with the Runwork
+platform in accordance with the Runwork Terms of Service.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND TITLE.

package/dist/api/client.d.ts

@@ -63,6 +63,28 @@ export declare class ApiClient {
         filePath: string;
         fileContents: string;
     }>, deletedFiles?: string[]): Promise<void>;
+    searchIntegrations(query: string, limit?: number): Promise<{
+        results: Array<{
+            id: string;
+            name: string;
+            provider: string;
+            docs?: {
+                name: string;
+                baseUrl: string;
+                pathFormat: string;
+                examples: string[];
+                notes?: string[];
+                requiredSetup?: string;
+            };
+        }>;
+    }>;
+    listConnectedIntegrations(workspaceId: string): Promise<Array<{
+        integrationId: string;
+        canonicalId?: string;
+        provider: string;
+        status?: string;
+        createdAt?: string;
+    }>>;
     /**
      * Get git remote URL for an app.
      * Both canonical ({baseUrl}/api/git/{workspaceId}/{appId}) and

package/dist/api/client.js

@@ -133,6 +133,15 @@ export class ApiClient {
             body: JSON.stringify({ files, deletedFiles }),
         });
     }
+    async searchIntegrations(query, limit = 20) {
+        const params = new URLSearchParams({ q: query, limit: String(limit) });
+        const res = await this.request(`/api/integrations/search?${params}`);
+        return res.data;
+    }
+    async listConnectedIntegrations(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/integrations`);
+        return res.data.integrations;
+    }
     /**
      * Get git remote URL for an app.
      * Both canonical ({baseUrl}/api/git/{workspaceId}/{appId}) and

package/dist/commands/dev.js

@@ -1,10 +1,11 @@
 import { Command } from 'commander';
 import { execFileSync } from 'child_process';
-import { readFileSync, writeFileSync, existsSync, unlinkSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { watchAndAutoCommit, stopAutoCommit } from '../git/auto-commit.js';
+import { syncWithRemote } from '../git/sync.js';
 import { startLogTailer } from '../logs/tailer.js';
 import { populateTypes } from '../types-manager.js';
 import { loadManifest, generateManifest, saveManifest, detectUserEdits } from '../template/manifest.js';
@@ -28,25 +29,6 @@ function readConfig() {
     }
     return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
 }
-function hasCommits() {
-    try {
-        execFileSync('git', ['rev-parse', 'HEAD'], { stdio: 'pipe' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function hasTrackedChanges() {
-    try {
-        // Only check tracked files (modified/deleted/staged) - not untracked (??) files
-        const output = execFileSync('git', ['status', '--porcelain'], { encoding: 'utf-8' });
-        return output.trim().split('\n').some(line => line.length > 0 && !line.startsWith('??'));
-    }
-    catch {
-        return false;
-    }
-}
 export const devCommand = new Command('dev')
     .description('Start local development server with live sync')
     .option('--no-logs', 'Disable automatic log tailing')
@@ -103,60 +85,28 @@ export const devCommand = new Command('dev')
     // Fetch SKILL.md (best-effort, after session so DO registries are available)
     await populateSkill(cwd, client, config.appId);
     // Sync AFTER starting session so we pick up any commits the DO created
-    if (hasCommits()) {
-        console.log('Syncing with Runwork...');
-        const dirty = hasTrackedChanges();
-        if (dirty) {
-            execFileSync('git', ['stash', 'push', '-m', 'runwork-dev-sync'], { stdio: 'inherit' });
-        }
-        try {
-            // Fetch first, then remove untracked skeleton files that conflict
-            // with the remote before rebasing. Skeleton files are ephemeral
-            // (re-downloaded each session) so the server's versions take precedence.
-            // User-edited files are already tracked/committed at this point.
-            execFileSync('git', ['fetch', 'runwork', 'main'], { stdio: 'inherit' });
-            try {
-                const remoteFiles = execFileSync('git', ['ls-tree', '-r', '--name-only', 'runwork/main'], { encoding: 'utf-8' }).trim().split('\n');
-                const untrackedOutput = execFileSync('git', ['ls-files', '--others', '--exclude-standard'], { encoding: 'utf-8' }).trim();
-                const untracked = new Set(untrackedOutput.split('\n').filter(Boolean));
-                for (const file of remoteFiles) {
-                    if (untracked.has(file)) {
-                        try {
-                            unlinkSync(join(cwd, file));
-                        }
-                        catch { /* already gone */ }
-                    }
-                }
-            }
-            catch { /* best effort */ }
-            execFileSync('git', ['rebase', 'runwork/main'], { stdio: 'inherit' });
-        }
-        catch {
-            try {
-                execFileSync('git', ['rebase', '--abort'], { stdio: 'pipe' });
-            }
-            catch { /* no rebase in progress */ }
-            console.warn('Pull failed (remote may not have commits yet). Continuing...');
-        }
-        if (dirty) {
-            try {
-                execFileSync('git', ['stash', 'pop'], { stdio: 'inherit' });
-            }
-            catch {
+    console.log('Syncing with Runwork...');
+    const syncResult = syncWithRemote(cwd);
+    switch (syncResult.status) {
+        case 'skipped':
+            console.log('No commits yet. Skipping sync.');
+            break;
+        case 'synced':
+            console.log('Synced with Runwork.');
+            break;
+        case 'merged':
+            console.log('Merged with Runwork (histories diverged).');
+            break;
+        case 'sync-failed':
+            if (syncResult.error === 'stash-conflict') {
                 console.error('Merge conflicts detected after stash pop. Resolve conflicts and restart.');
                 process.exit(1);
             }
-        }
-        // Push local changes
-        try {
-            execFileSync('git', ['push', 'runwork', 'main'], { stdio: 'inherit' });
-        }
-        catch {
-            console.warn('Push failed. Continuing with current state...');
-        }
+            console.warn('Pull failed (remote may not have commits yet). Continuing...');
+            break;
     }
-    else {
-        console.log('No commits yet. Skipping sync.');
+    if (!syncResult.pushed && syncResult.status !== 'skipped' && syncResult.status !== 'sync-failed') {
+        console.warn('Push failed. Continuing with current state...');
     }
     // Declare logTailer before cleanup so cleanup can reference it
     let logTailer;

package/dist/commands/integrations.d.ts

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

package/dist/commands/integrations.js

@@ -0,0 +1,86 @@
+import { Command } from 'commander';
+import { requireAuth } from '../auth/store.js';
+import { ApiClient } from '../api/client.js';
+import { readFileSync, existsSync } from 'fs';
+function readConfig() {
+    if (!existsSync('.runwork.json')) {
+        console.error('No .runwork.json found. Run `runwork init` first.');
+        process.exit(1);
+    }
+    return JSON.parse(readFileSync('.runwork.json', 'utf-8'));
+}
+const searchCommand = new Command('search')
+    .description('Search available integrations from the platform catalog')
+    .argument('<query>', 'Search query (e.g., "google drive", "hubspot", "slack")')
+    .option('--limit <n>', 'Maximum results to show', '20')
+    .action(async (query, opts) => {
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const limit = parseInt(opts.limit, 10);
+    try {
+        const { results } = await client.searchIntegrations(query, limit);
+        if (results.length === 0) {
+            console.log(`No integrations found for "${query}".`);
+            console.log('Try broader terms (e.g., "calendar" instead of "google calendar").');
+            return;
+        }
+        console.log(`Found ${results.length} integration(s) for "${query}":\n`);
+        for (const r of results) {
+            console.log(`  ${r.id} - ${r.name} (${r.provider})`);
+            if (r.docs) {
+                console.log(`    Base URL: ${r.docs.baseUrl}`);
+                console.log(`    Path format: ${r.docs.pathFormat}`);
+                if (r.docs.examples && r.docs.examples.length > 0) {
+                    console.log(`    Endpoints:`);
+                    for (const example of r.docs.examples) {
+                        console.log(`      ${example}`);
+                    }
+                }
+                if (r.docs.notes && r.docs.notes.length > 0) {
+                    for (const note of r.docs.notes) {
+                        console.log(`    Note: ${note}`);
+                    }
+                }
+                if (r.docs.requiredSetup) {
+                    console.log(`    Setup: ${r.docs.requiredSetup}`);
+                }
+            }
+            console.log('');
+        }
+        console.log('\nUsage: Add the integration ID to APP_INTEGRATION_REQUIREMENTS in worker/integration-requirements.ts');
+    }
+    catch (err) {
+        console.error('Failed to search integrations:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+const listCommand = new Command('list')
+    .description('List connected workspace integrations')
+    .action(async () => {
+    const credentials = requireAuth();
+    const client = new ApiClient(credentials);
+    const config = readConfig();
+    try {
+        const integrations = await client.listConnectedIntegrations(config.workspaceId);
+        if (integrations.length === 0) {
+            console.log('No integrations connected in this workspace.');
+            console.log('Connect integrations at https://runwork.ai/workspace-settings');
+            return;
+        }
+        console.log(`Connected integrations (${integrations.length}):\n`);
+        for (const i of integrations) {
+            const id = i.canonicalId || i.integrationId;
+            const status = i.status || 'connected';
+            const date = i.createdAt ? ` (since ${new Date(i.createdAt).toLocaleDateString()})` : '';
+            console.log(`  ${id} - ${i.provider}${date} [${status}]`);
+        }
+    }
+    catch (err) {
+        console.error('Failed to list integrations:', err instanceof Error ? err.message : err);
+        process.exit(1);
+    }
+});
+export const integrationsCommand = new Command('integrations')
+    .description('Search and manage workspace integrations')
+    .addCommand(searchCommand)
+    .addCommand(listCommand);

package/dist/commands/upgrade.d.ts

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

package/dist/commands/upgrade.js

@@ -0,0 +1,165 @@
+import { Command } from 'commander';
+import { execFileSync } from 'child_process';
+import { VERSION } from '../generated/version.js';
+const GITHUB_REPO = 'runwork-ai/cli';
+const INSTALL_SCRIPT_URL = 'https://runwork.ai/install.sh';
+async function fetchLatestVersion() {
+    try {
+        const response = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`);
+        if (!response.ok)
+            return null;
+        const data = await response.json();
+        return data.tag_name?.replace(/^v/, '') || null;
+    }
+    catch {
+        return null;
+    }
+}
+function detectInstallMethod() {
+    try {
+        const binaryPath = process.argv[1] || '';
+        // Homebrew: /opt/homebrew/Cellar/runwork/... or /usr/local/Cellar/runwork/...
+        if (binaryPath.includes('/Cellar/runwork/') || binaryPath.includes('/homebrew/')) {
+            return 'brew';
+        }
+        // Volta: ~/.volta/tools/image/packages/runwork/...
+        if (binaryPath.includes('/.volta/')) {
+            return 'volta';
+        }
+        // Bun global: ~/.bun/install/global/... or ~/.bun/bin/...
+        if (binaryPath.includes('/.bun/')) {
+            return 'bun';
+        }
+        // pnpm global: ~/.local/share/pnpm/... or pnpm/global/...
+        if (binaryPath.includes('/pnpm/') || binaryPath.includes('/.pnpm/')) {
+            return 'pnpm';
+        }
+        // Yarn global: ~/.yarn/bin/... or ~/.config/yarn/global/...
+        if (binaryPath.includes('/.yarn/') || binaryPath.includes('/yarn/global/')) {
+            return 'yarn';
+        }
+        // npm global: node_modules or /lib/node/ in path
+        if (binaryPath.includes('node_modules') || binaryPath.includes('/lib/node/')) {
+            return 'npm';
+        }
+    }
+    catch {
+        // Fall through to binary
+    }
+    return 'binary';
+}
+export const upgradeCommand = new Command('upgrade')
+    .description('Upgrade Runwork CLI to the latest version')
+    .option('--check', 'Check for updates without installing')
+    .action(async (options) => {
+    console.log(`Current version: ${VERSION}`);
+    const latest = await fetchLatestVersion();
+    if (!latest) {
+        console.error('Could not fetch latest version. Check your internet connection.');
+        process.exit(1);
+    }
+    if (latest === VERSION) {
+        console.log(`Already on the latest version (${VERSION}).`);
+        return;
+    }
+    console.log(`Latest version:  ${latest}`);
+    if (options.check) {
+        console.log(`\nRun \`runwork upgrade\` to install the update.`);
+        return;
+    }
+    const method = detectInstallMethod();
+    if (method === 'brew') {
+        console.log('\nDetected installation method: brew');
+        console.log('Upgrading via Homebrew...\n');
+        try {
+            execFileSync('brew', ['update', '--quiet'], { stdio: 'inherit' });
+            execFileSync('brew', ['upgrade', 'runwork'], { stdio: 'inherit' });
+            console.log('\nUpgraded successfully via Homebrew.');
+        }
+        catch {
+            console.error('\nHomebrew upgrade failed. Try manually: brew update && brew upgrade runwork');
+            process.exit(1);
+        }
+        return;
+    }
+    if (method === 'bun') {
+        console.log('\nDetected installation method: bun');
+        console.log('Upgrading via bun...\n');
+        try {
+            execFileSync('bun', ['install', '-g', 'runwork@latest'], { stdio: 'inherit' });
+            console.log('\nUpgraded successfully via bun.');
+        }
+        catch {
+            console.error('\nbun upgrade failed. Try manually: bun install -g runwork@latest');
+            process.exit(1);
+        }
+        return;
+    }
+    if (method === 'pnpm') {
+        console.log('\nDetected installation method: pnpm');
+        console.log('Upgrading via pnpm...\n');
+        try {
+            execFileSync('pnpm', ['update', '-g', 'runwork'], { stdio: 'inherit' });
+            console.log('\nUpgraded successfully via pnpm.');
+        }
+        catch {
+            console.error('\npnpm upgrade failed. Try manually: pnpm update -g runwork');
+            process.exit(1);
+        }
+        return;
+    }
+    if (method === 'yarn') {
+        console.log('\nDetected installation method: yarn');
+        console.log('Upgrading via yarn...\n');
+        try {
+            execFileSync('yarn', ['global', 'upgrade', 'runwork'], { stdio: 'inherit' });
+            console.log('\nUpgraded successfully via yarn.');
+        }
+        catch {
+            console.error('\nyarn upgrade failed. Try manually: yarn global upgrade runwork');
+            process.exit(1);
+        }
+        return;
+    }
+    if (method === 'volta') {
+        console.log('\nDetected installation method: volta');
+        console.log('Upgrading via Volta...\n');
+        try {
+            execFileSync('volta', ['install', 'runwork@latest'], { stdio: 'inherit' });
+            console.log('\nUpgraded successfully via Volta.');
+        }
+        catch {
+            console.error('\nVolta upgrade failed. Try manually: volta install runwork@latest');
+            process.exit(1);
+        }
+        return;
+    }
+    if (method === 'npm') {
+        console.log('\nDetected installation method: npm');
+        console.log('Upgrading via npm...\n');
+        try {
+            execFileSync('npm', ['update', '-g', 'runwork'], { stdio: 'inherit' });
+            console.log('\nUpgraded successfully via npm.');
+        }
+        catch {
+            console.error('\nnpm upgrade failed. Try manually: npm update -g runwork');
+            process.exit(1);
+        }
+        return;
+    }
+    // Binary install: download install script and pipe to sh
+    console.log('\nUpgrading via install script...\n');
+    try {
+        const response = await fetch(INSTALL_SCRIPT_URL);
+        if (!response.ok) {
+            throw new Error(`Failed to download install script: ${response.status}`);
+        }
+        const script = await response.text();
+        execFileSync('sh', ['-c', script], { stdio: 'inherit' });
+        console.log('\nUpgraded successfully.');
+    }
+    catch (error) {
+        console.error(`\nUpgrade failed. Try manually: curl -fsSL ${INSTALL_SCRIPT_URL} | sh`);
+        process.exit(1);
+    }
+});