runwork 0.13.3 → 0.14.0

package/bundled-types/core-endpoints.d.ts

@@ -10,9 +10,16 @@ import { z } from 'zod';
 import type { Hono } from 'hono';
 type ZodSchema = z.ZodType<any, any, any>;
 /**
- * Authentication type for public endpoints
+ * Authentication requirement declared by an endpoint definition.
  */
 export type EndpointAuthType = 'apiKey' | 'public';
+/**
+ * Caller principal type resolved by the platform and passed via the
+ * `X-Public-Endpoint-Auth-Type` header. `user` and `workspace_key` are
+ * authenticated principals the platform has already authorized; `api_key`
+ * additionally carries a validated key id; `none` is unauthenticated.
+ */
+export type EndpointPrincipalType = 'none' | 'api_key' | 'workspace_key' | 'user';
 /**
  * HTTP methods supported by endpoints
  */
@@ -53,10 +60,14 @@ export interface EndpointContext<TQuery = Record<string, unknown>, TBody = unkno
  * Authentication information passed to handlers
  */
 export interface EndpointAuthInfo {
-    /** Authentication type used */
+    /** Authentication requirement declared by the endpoint */
     type: EndpointAuthType;
-    /** API key ID (if authenticated with API key) */
+    /** Resolved caller principal type (api_key, workspace_key, user, none) */
+    principalType?: EndpointPrincipalType;
+    /** API key ID (if authenticated with an API key) */
     apiKeyId?: string;
+    /** User ID (if authenticated as a workspace member) */
+    userId?: string;
     /** Scopes granted to the API key */
     scopes?: string[];
     /** Whether request is authenticated */
@@ -112,8 +123,9 @@ export declare function isEndpointDefinition(entry: unknown): entry is EndpointD
 export interface ParsedEndpointRequest {
     endpointId: string;
     appId: string;
-    authType: EndpointAuthType;
+    authType: EndpointPrincipalType;
     apiKeyId?: string;
+    userId?: string;
     scopes?: string[];
 }
 /**

package/bundled-types/core-workflow-instance.d.ts

@@ -9,6 +9,12 @@ import { DurableObject } from 'cloudflare:workers';
 import type { NativeWorkflowInstance, NativeWorkflowConfig } from './core-workflow-types';
 import type { StepOptions, WaitEventOptions } from './core-workflows';
 import { type Env } from './core-utils';
+export declare class WorkflowPausedError extends Error {
+    reason: 'sleep' | 'waitEvent';
+    resumeAt?: number | undefined;
+    constructor(reason: 'sleep' | 'waitEvent', resumeAt?: number | undefined);
+}
+export declare function isWorkflowControlSignal(error: unknown): boolean;
 /**
  * WorkflowInstance Durable Object
  *

package/bundled-types/workflows.d.ts

@@ -12,3 +12,4 @@ export { DEFAULT_WORKFLOW_CONFIG } from './core-workflow-types';
 export { WORKFLOW_INFRA_MODE } from './core-workflow-config';
 export { WorkflowInstanceDO } from './core-workflow-instance';
 export { WorkflowCoordinator } from './core-workflow-coordinator';
+export { WorkflowPausedError, isWorkflowControlSignal } from './core-workflow-instance';

package/dist/agents/claude-desktop-plugin-tree.js

@@ -1,6 +1,6 @@
 import { chmodSync, mkdirSync, rmSync, existsSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { appendTokenToUrl, buildSkillMd } from './types.js';
+import { appendTokenToUrl, buildSkillMd, RUNWORK_WORKSPACE_MCP_NAME } from './types.js';
 import { SESSION_START_HOOK_SCRIPT } from './session-start-hook.js';
 /**
  * Write <destDir>/.claude-plugin/plugin.json.
@@ -24,13 +24,28 @@ export function writePluginMcpConfig(destDir, mcpServers) {
     mkdirSync(destDir, { recursive: true });
     const mcpEntries = {};
     for (const server of mcpServers) {
-        const token = server.headers?.Authorization?.replace(/^Bearer\s+/i, '');
-        const connectorUrl = token ? appendTokenToUrl(server.url, token) : server.url;
-        mcpEntries[server.name] = {
-            type: 'http',
-            url: connectorUrl,
-            ...(server.description ? { description: server.description } : {}),
-        };
+        if (server.name === RUNWORK_WORKSPACE_MCP_NAME) {
+            // Preserve the exact, known-working behavior for the Runwork connector: embed
+            // the workspace key in the URL, no headers field. Claude Desktop's native
+            // connector did not reliably honor request headers here, which is why the token
+            // lives in the URL — do NOT change this.
+            const token = server.headers?.Authorization?.replace(/^Bearer\s+/i, '');
+            mcpEntries[server.name] = {
+                type: 'http',
+                url: token ? appendTokenToUrl(server.url, token) : server.url,
+                ...(server.description ? { description: server.description } : {}),
+            };
+        }
+        else {
+            // Third-party servers: forward the auth header map (same .mcp.json schema
+            // claude-code uses). Their secrets must NEVER be placed in the URL.
+            mcpEntries[server.name] = {
+                type: 'http',
+                url: server.url,
+                ...(server.headers ? { headers: server.headers } : {}),
+                ...(server.description ? { description: server.description } : {}),
+            };
+        }
     }
     writeFileSync(join(destDir, '.mcp.json'), JSON.stringify({ mcpServers: mcpEntries }, null, 2));
 }

package/dist/agents/claude-desktop.js

@@ -189,12 +189,15 @@ export class ClaudeDesktopAdapter {
         // For cowork connectors, embed the auth token in the URL query string.
         // This lets Claude Desktop connect without requiring the user to go through
         // an OAuth flow or manually click "Connect" in the Connectors UI.
-        // Write to claude_desktop_config.json via mcp-remote (chat mode fallback)
+        // Write to claude_desktop_config.json via mcp-remote (chat mode fallback).
+        // Forward every auth header (Authorization, X-Api-Key, etc.) as a --header arg.
         const entries = {};
         for (const s of servers) {
             const args = ['mcp-remote', s.url];
-            if (s.headers?.Authorization) {
-                args.push('--header', `Authorization:${s.headers.Authorization}`);
+            if (s.headers) {
+                for (const [name, value] of Object.entries(s.headers)) {
+                    args.push('--header', `${name}:${value}`);
+                }
             }
             entries[s.name] = {
                 command: 'npx',

package/dist/agents/codex.js

@@ -45,15 +45,23 @@ export class CodexAdapter {
                 delete mcpServers[key];
             }
         }
-        // Add new entries (sanitize names to match Codex's ^[a-zA-Z0-9_-]+$ requirement)
+        // Add new entries (sanitize names to match Codex's ^[a-zA-Z0-9_-]+$ requirement).
         for (const s of servers) {
             const safeName = s.name.replace(/[^a-zA-Z0-9_-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
-            // Embed auth token in URL so Codex doesn't need a separate env var
-            const token = s.headers?.Authorization?.replace(/^Bearer\s+/i, '');
-            const serverUrl = token ? appendTokenToUrl(s.url, token) : s.url;
-            mcpServers[safeName] = {
-                url: serverUrl,
-            };
+            const entry = { url: s.url };
+            if (s.name === RUNWORK_WORKSPACE_MCP_NAME) {
+                // Preserve the known-working behavior: embed the workspace key in the URL.
+                // Codex's header-based auth was historically unreliable here, so do NOT change it.
+                const token = s.headers?.Authorization?.replace(/^Bearer\s+/i, '');
+                if (token)
+                    entry.url = appendTokenToUrl(s.url, token);
+            }
+            else if (s.headers && Object.keys(s.headers).length > 0) {
+                // External servers: forward headers via Codex's documented http_headers field
+                // (static literal values). These had no prior working path, so this is additive.
+                entry.http_headers = s.headers;
+            }
+            mcpServers[safeName] = entry;
         }
         mkdirSync(join(configPath, '..'), { recursive: true });
         writeFileSync(configPath, stringify(parsed));

package/dist/api/client.d.ts

@@ -141,6 +141,11 @@ export declare class ApiClient {
         transport: 'sse' | 'streamable-http';
     }): Promise<McpServerConfig>;
     removeMcpServer(workspaceId: string, serverId: string): Promise<void>;
+    /**
+     * Resolve decrypted auth headers for header-auth MCP servers, scoped to the
+     * authenticated user (their own + workspace-wide credentials). Keyed by server id.
+     */
+    resolveMcpCredentials(workspaceId: string): Promise<Record<string, Record<string, string>>>;
     searchCommunitySkills(query: string, limit?: number, includeContent?: boolean): Promise<{
         query: string;
         count: number;

package/dist/api/client.js

@@ -194,6 +194,14 @@ export class ApiClient {
     async removeMcpServer(workspaceId, serverId) {
         await this.request(`/api/workspaces/${workspaceId}/mcp-servers/${serverId}`, { method: 'DELETE' });
     }
+    /**
+     * Resolve decrypted auth headers for header-auth MCP servers, scoped to the
+     * authenticated user (their own + workspace-wide credentials). Keyed by server id.
+     */
+    async resolveMcpCredentials(workspaceId) {
+        const res = await this.request(`/api/workspaces/${workspaceId}/mcp-credentials/resolved`);
+        return res.data.servers;
+    }
     // --- Community Marketplace ---
     async searchCommunitySkills(query, limit = 10, includeContent = false) {
         const res = await this.request(`/api/community/skills/search?q=${encodeURIComponent(query)}&limit=${limit}&include_content=${includeContent}`);

package/dist/commands/__tests__/mcp-entries.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/__tests__/mcp-entries.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { buildExternalMcpEntries } from '../mcp-entries.js';
+const PLATFORM_KEY = 'rk_ws_live_supersecretplatformkey';
+function server(overrides) {
+    return {
+        id: 'srv-1',
+        name: 'example',
+        url: 'https://mcp.example.com',
+        transport: 'streamable-http',
+        enabled: true,
+        addedAt: 0,
+        addedBy: 'user-1',
+        ...overrides,
+    };
+}
+describe('buildExternalMcpEntries', () => {
+    it('never injects the Runwork platform key onto external entries', () => {
+        const entries = buildExternalMcpEntries([
+            server({ id: 'a', authType: 'header' }),
+            server({ id: 'b', authType: 'oauth' }),
+            server({ id: 'c', authType: 'none' }),
+            server({ id: 'd' }), // authType unset
+        ], { a: { Authorization: 'Bearer user-token' } });
+        // Regression: the platform key must not appear anywhere in the output.
+        expect(JSON.stringify(entries)).not.toContain(PLATFORM_KEY);
+    });
+    it('injects resolved per-server headers for header-auth servers', () => {
+        const entries = buildExternalMcpEntries([server({ id: 'a', authType: 'header' })], { a: { Authorization: 'Bearer tok', 'X-Api-Key': 'key123' } });
+        expect(entries[0].headers).toEqual({ Authorization: 'Bearer tok', 'X-Api-Key': 'key123' });
+    });
+    it('emits no auth header for oauth servers (local agent runs its own flow)', () => {
+        const entries = buildExternalMcpEntries([server({ id: 'a', authType: 'oauth' })], { a: { Authorization: 'Bearer should-not-be-used' } });
+        expect(entries[0].headers).toBeUndefined();
+    });
+    it('emits no auth header for none/unset servers', () => {
+        const entries = buildExternalMcpEntries([server({ id: 'a', authType: 'none' }), server({ id: 'b' })], {});
+        expect(entries[0].headers).toBeUndefined();
+        expect(entries[1].headers).toBeUndefined();
+    });
+    it('omits headers when a header-auth server has no resolved credentials', () => {
+        const entries = buildExternalMcpEntries([server({ id: 'a', authType: 'header' })], {});
+        expect(entries[0].headers).toBeUndefined();
+    });
+    it('skips disabled servers', () => {
+        const entries = buildExternalMcpEntries([server({ id: 'a', enabled: false })], {});
+        expect(entries).toHaveLength(0);
+    });
+});

package/dist/commands/deploy.js

@@ -1,13 +1,20 @@
 import { Command } from 'commander';
-import { execFileSync } from '../utils/subprocess.js';
 import { readFileSync, existsSync } from 'fs';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { shouldOutputJson, jsonOut } from '../utils/output.js';
 import { buildDeployGuide, buildErrorResponse } from '../utils/agent-guidance.js';
+import { requireGit } from '../git/preflight.js';
+import { ensureGitIdentity } from '../git/identity.js';
+import { commitWorkingTree } from '../git/auto-commit.js';
+import { syncWithRemote, hasCommits } from '../git/sync.js';
+import { snapshotCriticalFiles, restoreMissingCriticalFiles, commitAndPushRestoredFiles } from '../git/critical-files.js';
+import { evaluateDeployGuard } from '../git/deploy-guard.js';
+import { promptConfirm } from '../utils/prompt.js';
 export const deployCommand = new Command('deploy')
     .description('Deploy the current app to production')
-    .action(async (_opts, command) => {
+    .option('-y, --yes', 'Skip the confirmation prompt when the working tree differs from the preview')
+    .action(async (opts, command) => {
     const useJson = shouldOutputJson(command.optsWithGlobals().json);
     if (!existsSync('.runwork.json')) {
         if (useJson) {
@@ -17,36 +24,93 @@ export const deployCommand = new Command('deploy')
         console.error('No .runwork.json found. Run `runwork init` first.');
         process.exit(1);
     }
+    requireGit('deploy');
     const config = JSON.parse(readFileSync('.runwork.json', 'utf-8'));
     const creds = requireAuth();
     const client = new ApiClient(creds);
-    // Sync: pull + push (skip if no commits yet)
-    let repoHasCommits = false;
+    const cwd = process.cwd();
+    // Deploy guard: the preview reflects the last *pushed* commit. If the
+    // working tree is dirty or ahead of `runwork/main` and no auto-syncing
+    // dev session is keeping the preview in lockstep, `runwork deploy` will
+    // commit and ship code the user never saw in the preview. Warn first.
+    // Runs BEFORE the commit/sync/deploy steps below, which are unchanged.
+    const guard = evaluateDeployGuard(cwd, config.appId);
+    let deployGuardWarning;
+    if (guard.warn) {
+        deployGuardWarning = 'You have uncommitted or unpushed changes. `runwork deploy` will commit and deploy them, but they are not reflected in the preview.';
+        if (useJson) {
+            // Agents must never be blocked: the warning rides along in the
+            // final success response below so we proceed without prompting.
+        }
+        else if (opts.yes || !process.stdin.isTTY) {
+            // Non-interactive (no TTY) or explicit --yes: warn and proceed.
+            console.warn(deployGuardWarning);
+        }
+        else {
+            console.warn(deployGuardWarning);
+            const proceed = await promptConfirm('Deploy these changes anyway?');
+            if (!proceed) {
+                console.log('Deploy cancelled.');
+                process.exit(0);
+            }
+        }
+    }
+    // Deploy must work even when no `runwork dev` session is (or ever was)
+    // running. Reuse the exact sync path dev uses: commit any pending
+    // working-tree changes, then fetch -> rebase (fallback merge) -> push.
+    // `ensureGitIdentity` seeds a local identity so the commit cannot fail
+    // on a fresh machine where git user.email/.name were never configured.
+    ensureGitIdentity(cwd, creds);
+    if (!useJson)
+        console.log('Syncing...');
     try {
-        execFileSync('git', ['rev-parse', 'HEAD'], { stdio: 'pipe' });
-        repoHasCommits = true;
+        commitWorkingTree(cwd, `deploy: ${new Date().toISOString().replace('T', ' ').slice(0, 19)}`);
     }
     catch {
-        // No commits yet
+        // No commit created (clean tree) or git not initialized yet. The
+        // sync/push step below surfaces the actionable failure.
+    }
+    if (!hasCommits(cwd)) {
+        if (useJson) {
+            jsonOut(buildErrorResponse('deploy', 'Nothing to deploy', 'No commits exist and the working tree has no changes to commit, so there is nothing to sync or deploy.', ['Make changes to your app first', 'Run runwork dev to develop and verify changes', 'Then run runwork deploy']));
+            process.exit(1);
+        }
+        console.error('Nothing to deploy. Make changes first, then run `runwork deploy`.');
+        process.exit(1);
     }
-    if (repoHasCommits) {
-        if (!useJson)
-            console.log('Syncing...');
-        try {
-            execFileSync('git', ['pull', '--rebase', 'runwork', 'main'], { stdio: useJson ? 'pipe' : 'inherit' });
+    // Protect critical files across the sync exactly as `runwork dev` does:
+    // syncWithRemote may merge with `-X theirs` (remote wins) to reconcile
+    // diverged histories, which can delete `.runwork.json`/`blueprint.json`/
+    // `.gitignore` if the remote tip lacks them. Snapshot before, restore after.
+    const criticalSnapshot = snapshotCriticalFiles(cwd);
+    const syncResult = syncWithRemote(cwd);
+    const restoredCriticalFiles = restoreMissingCriticalFiles(cwd, criticalSnapshot);
+    if (restoredCriticalFiles.length > 0) {
+        const pushed = commitAndPushRestoredFiles(cwd, restoredCriticalFiles);
+        if (!useJson) {
+            console.warn(`Sync removed critical file(s); restored: ${restoredCriticalFiles.join(', ')}`);
+            if (!pushed)
+                console.warn('Restoration committed locally but not pushed; will retry on next sync.');
         }
-        catch {
-            if (!useJson)
-                console.warn('Pull failed. Continuing...');
+    }
+    if (syncResult.status === 'sync-failed') {
+        const reason = syncResult.error && syncResult.error !== 'stash-conflict'
+            ? syncResult.error
+            : 'Local history could not be reconciled with the remote.';
+        if (useJson) {
+            jsonOut(buildErrorResponse('deploy', 'Sync failed before deployment', reason, ['Run git fetch runwork && git rebase runwork/main and resolve any conflicts', 'Or run runwork dev to sync interactively', 'Then retry runwork deploy']));
+            process.exit(1);
         }
-        execFileSync('git', ['push', 'runwork', 'main'], { stdio: useJson ? 'pipe' : 'inherit' });
+        console.error(`Sync failed: ${reason}`);
+        console.error('Resolve conflicts (git status), or run `runwork dev`, then retry `runwork deploy`.');
+        process.exit(1);
     }
-    else {
+    if (!syncResult.pushed) {
         if (useJson) {
-            jsonOut(buildErrorResponse('deploy', 'Sync failed before deployment', 'Files could not be synced to the remote.', ['Run runwork dev first to ensure files sync correctly', 'Check your network connection', 'Retry runwork deploy']));
+            jsonOut(buildErrorResponse('deploy', 'Failed to push before deployment', 'Local commits were synced but could not be pushed to the remote.', ['Check your network connection', 'Run runwork dev to retry syncing', 'Then retry runwork deploy']));
             process.exit(1);
         }
-        console.error('No commits to deploy. Commit your changes first.');
+        console.error('Push failed. Check your connection and retry `runwork deploy`.');
         process.exit(1);
     }
     // Trigger deploy
@@ -65,19 +129,34 @@ export const deployCommand = new Command('deploy')
         console.error(`Deploy failed: ${message}`);
         process.exit(1);
     }
+    // The server returns a deployment URL only when a deploy actually
+    // happened. An empty/missing URL means the deploy was a no-op or did
+    // not produce a live deployment, so we must not report success.
+    const deploymentUrl = result.deploymentUrl?.trim() ?? '';
+    const deployed = deploymentUrl.length > 0;
+    if (!deployed) {
+        if (useJson) {
+            jsonOut(buildErrorResponse('deploy', 'Deployment did not produce a URL', 'The deploy API returned no deployment URL. The deploy may have been a no-op (no changes) or failed server-side.', ['Confirm your changes were committed and pushed (the sync step above succeeded)', 'Run runwork info to check the deployed state', 'Run runwork logs --production to inspect server-side errors', 'Retry runwork deploy']));
+            process.exit(1);
+        }
+        console.error('Deploy did not return a URL. The deploy may have been a no-op or failed server-side.');
+        console.error('Run `runwork info` to check state, or `runwork logs --production` to inspect errors.');
+        process.exit(1);
+    }
     if (useJson) {
         const response = {
             success: true,
             command: 'deploy',
             result: {
-                deployed: true,
-                url: result.deploymentUrl,
+                deployed,
+                url: deploymentUrl,
                 appName: config.appName,
             },
             guide: buildDeployGuide(),
+            ...(deployGuardWarning ? { warning: deployGuardWarning } : {}),
         };
         jsonOut(response);
         return;
     }
-    console.log(`Deployed: ${result.deploymentUrl}`);
+    console.log(`Deployed: ${deploymentUrl}`);
 });

package/dist/commands/dev.d.ts

@@ -6,5 +6,6 @@ export declare function execDev(options?: {
     json?: boolean;
     mode?: SessionMode;
     restart?: boolean;
+    noSync?: boolean;
 }): Promise<void>;
 export declare const devCommand: Command;