runwork 0.9.4 → 0.10.1

package/dist/git/__tests__/preflight.test.js

@@ -0,0 +1,36 @@
+import { describe, it, expect } from 'vitest';
+import { probeGit, buildMissingGitMessage } from '../preflight.js';
+describe('probeGit', () => {
+    it('reports installed=true when git is on PATH (CI invariant)', () => {
+        // The CLI test suite already shells out to git in many other tests, so
+        // we treat git as a hard prerequisite for this package's own tests.
+        const probe = probeGit();
+        expect(probe.installed).toBe(true);
+        expect(probe.version).toMatch(/^git version /);
+    });
+});
+describe('buildMissingGitMessage', () => {
+    it('mentions the failing command name', () => {
+        const msg = buildMissingGitMessage('clone');
+        expect(msg).toContain('runwork clone');
+    });
+    it('lists install hints for all three OSes', () => {
+        const msg = buildMissingGitMessage('dev');
+        expect(msg).toMatch(/macOS/);
+        expect(msg).toMatch(/Windows/);
+        expect(msg).toMatch(/Linux/);
+    });
+    it('ends with a verification command', () => {
+        const msg = buildMissingGitMessage('init');
+        expect(msg).toContain('git --version');
+    });
+    it('only includes the Windows-shell-PATH hint when running on Windows', () => {
+        const msg = buildMissingGitMessage('clone');
+        if (process.platform === 'win32') {
+            expect(msg).toMatch(/cached when it opened/);
+        }
+        else {
+            expect(msg).not.toMatch(/cached when it opened/);
+        }
+    });
+});

package/dist/git/auto-commit.js

@@ -188,12 +188,18 @@ function commitAndPush() {
                 return;
             }
         }
+        // Push the current HEAD to the remote's `main` branch regardless of
+        // what the local branch is named. This way `git init` defaults of
+        // `master` (older Git) or any other custom branch name still sync
+        // cleanly to runwork's `main`. Without `HEAD:main`, `git push runwork
+        // main` fails with "src refspec main does not match any" when the
+        // local branch isn't called `main`.
         try {
             execFileSync('git', ['rev-parse', '--abbrev-ref', '@{u}'], { stdio: 'pipe' });
-            execFileSync('git', ['push', 'runwork', 'main'], { stdio: 'pipe' });
+            execFileSync('git', ['push', 'runwork', 'HEAD:main'], { stdio: 'pipe' });
         }
         catch {
-            execFileSync('git', ['push', '-u', 'runwork', 'main'], { stdio: 'pipe' });
+            execFileSync('git', ['push', '-u', 'runwork', 'HEAD:main'], { stdio: 'pipe' });
         }
         console.log(dim(`  Pushed ${stagedFiles.length} file(s) to git.`));
         activeCallbacks?.onGitPush?.(stagedFiles.length);

package/dist/git/credentials.js

@@ -32,7 +32,7 @@ export async function removeGitCredentials(baseUrl) {
         execFileSync('git', [
             'config', '--global', '--unset',
             `credential.${origin}.helper`,
-        ]);
+        ], { stdio: 'pipe' });
     }
     catch {
         // Ignore errors if the config key doesn't exist

package/dist/git/identity.d.ts

@@ -0,0 +1,44 @@
+import type { Credentials } from '../types.js';
+/**
+ * Derive a human-friendly display name from an email address. Used when the
+ * credentials store only has the email (which is the common case). e.g.
+ * "oytun@motaword.com" -> "Oytun"; "anna.maria@example.com" -> "Anna Maria".
+ */
+declare function deriveNameFromEmail(email: string): string;
+declare function pickIdentity(creds?: Credentials | null): {
+    email: string;
+    name: string;
+};
+/**
+ * Ensure the repository at `cwd` has a usable git identity (user.email and
+ * user.name) and that, whenever possible, commits are attributed to the
+ * authenticated Runwork user.
+ *
+ * Precedence:
+ *   1. If we have usable Runwork credentials, always write local-scoped
+ *      `user.email` / `user.name` from those credentials. Commits to a
+ *      Runwork remote should be attributable to the logged-in Runwork user,
+ *      not to whatever generic identity the developer uses for unrelated
+ *      personal repos.
+ *   2. If credentials are missing or are an unusable placeholder
+ *      (e.g. API-key login), fall back to any existing global / system
+ *      configuration so the user's pre-existing identity still works.
+ *   3. If neither credentials nor any existing config are available, write a
+ *      synthetic local identity so the inevitable `git commit` does not fail
+ *      on a fresh Windows / minimal-container install with the classic
+ *      `unable to auto-detect email address` error.
+ *
+ * Local scope (`git config --local`) is mandatory: we never touch the user's
+ * global config so we cannot disturb identities they use elsewhere.
+ *
+ * Safe to call multiple times; it short-circuits when the desired identity
+ * is already in place.
+ */
+export declare function ensureGitIdentity(cwd: string, creds?: Credentials | null): void;
+export declare const __testing: {
+    deriveNameFromEmail: typeof deriveNameFromEmail;
+    pickIdentity: typeof pickIdentity;
+    FALLBACK_EMAIL: string;
+    FALLBACK_NAME: string;
+};
+export {};

package/dist/git/identity.js

@@ -0,0 +1,133 @@
+import { execFileSync } from 'child_process';
+/**
+ * Default identity used when we cannot derive anything better from the
+ * authenticated credentials. Local-scoped, never written to global config,
+ * so it does not leak into other repositories on the user's machine.
+ */
+const FALLBACK_EMAIL = 'runwork-cli@runwork.local';
+const FALLBACK_NAME = 'Runwork User';
+/**
+ * Derive a human-friendly display name from an email address. Used when the
+ * credentials store only has the email (which is the common case). e.g.
+ * "oytun@motaword.com" -> "Oytun"; "anna.maria@example.com" -> "Anna Maria".
+ */
+function deriveNameFromEmail(email) {
+    const local = email.split('@')[0] ?? '';
+    if (!local)
+        return FALLBACK_NAME;
+    const cleaned = local.replace(/[._+-]+/g, ' ').trim();
+    if (!cleaned)
+        return FALLBACK_NAME;
+    return cleaned
+        .split(/\s+/)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+function isUsableEmail(value) {
+    if (!value)
+        return false;
+    // Reject the "api-key-auth" placeholder used by API-key login flows.
+    if (!value.includes('@'))
+        return false;
+    return true;
+}
+function pickIdentity(creds) {
+    const email = isUsableEmail(creds?.email) ? creds.email : FALLBACK_EMAIL;
+    const name = email === FALLBACK_EMAIL ? FALLBACK_NAME : deriveNameFromEmail(email);
+    return { email, name };
+}
+function readGitConfig(cwd, key) {
+    try {
+        const value = execFileSync('git', ['config', '--get', key], { cwd, stdio: ['ignore', 'pipe', 'ignore'] });
+        return value.toString('utf-8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+function readLocalGitConfig(cwd, key) {
+    try {
+        const value = execFileSync('git', ['config', '--local', '--get', key], { cwd, stdio: ['ignore', 'pipe', 'ignore'] });
+        return value.toString('utf-8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Ensure the repository at `cwd` has a usable git identity (user.email and
+ * user.name) and that, whenever possible, commits are attributed to the
+ * authenticated Runwork user.
+ *
+ * Precedence:
+ *   1. If we have usable Runwork credentials, always write local-scoped
+ *      `user.email` / `user.name` from those credentials. Commits to a
+ *      Runwork remote should be attributable to the logged-in Runwork user,
+ *      not to whatever generic identity the developer uses for unrelated
+ *      personal repos.
+ *   2. If credentials are missing or are an unusable placeholder
+ *      (e.g. API-key login), fall back to any existing global / system
+ *      configuration so the user's pre-existing identity still works.
+ *   3. If neither credentials nor any existing config are available, write a
+ *      synthetic local identity so the inevitable `git commit` does not fail
+ *      on a fresh Windows / minimal-container install with the classic
+ *      `unable to auto-detect email address` error.
+ *
+ * Local scope (`git config --local`) is mandatory: we never touch the user's
+ * global config so we cannot disturb identities they use elsewhere.
+ *
+ * Safe to call multiple times; it short-circuits when the desired identity
+ * is already in place.
+ */
+export function ensureGitIdentity(cwd, creds) {
+    // Only act on actual git repos; refuse silently if `cwd` has no .git.
+    try {
+        execFileSync('git', ['rev-parse', '--git-dir'], { cwd, stdio: 'pipe' });
+    }
+    catch {
+        return;
+    }
+    const credsUsable = isUsableEmail(creds?.email);
+    // Path 1: real Runwork credentials -- always overwrite local config so the
+    // commit is attributed to the Runwork user, regardless of global state.
+    if (credsUsable) {
+        const { email, name } = pickIdentity(creds);
+        const existingLocalEmail = readLocalGitConfig(cwd, 'user.email');
+        const existingLocalName = readLocalGitConfig(cwd, 'user.name');
+        if (existingLocalEmail !== email) {
+            try {
+                execFileSync('git', ['config', '--local', 'user.email', email], { cwd, stdio: 'pipe' });
+            }
+            catch { /* read-only fs */ }
+        }
+        if (existingLocalName !== name) {
+            try {
+                execFileSync('git', ['config', '--local', 'user.name', name], { cwd, stdio: 'pipe' });
+            }
+            catch { /* read-only fs */ }
+        }
+        return;
+    }
+    // Path 2: no usable creds. Respect any pre-existing identity (global/local).
+    const existingEmail = readGitConfig(cwd, 'user.email');
+    const existingName = readGitConfig(cwd, 'user.name');
+    if (existingEmail && existingName)
+        return;
+    // Path 3: no creds AND no existing identity -- seed a synthetic fallback
+    // so commits do not fail on a fresh machine.
+    const { email, name } = pickIdentity(creds);
+    if (!existingEmail) {
+        try {
+            execFileSync('git', ['config', '--local', 'user.email', email], { cwd, stdio: 'pipe' });
+        }
+        catch { /* read-only fs */ }
+    }
+    if (!existingName) {
+        try {
+            execFileSync('git', ['config', '--local', 'user.name', name], { cwd, stdio: 'pipe' });
+        }
+        catch { /* read-only fs */ }
+    }
+}
+// Exported for unit tests so we do not have to re-derive expectations there.
+export const __testing = { deriveNameFromEmail, pickIdentity, FALLBACK_EMAIL, FALLBACK_NAME };

package/dist/git/preflight.d.ts

@@ -0,0 +1,28 @@
+export interface GitProbe {
+    installed: boolean;
+    /** Trimmed `git --version` output when detected; undefined otherwise. */
+    version?: string;
+    /** Underlying error for diagnostics (most often ENOENT on a missing git binary). */
+    error?: NodeJS.ErrnoException;
+}
+/**
+ * Probe whether `git` is callable from this process. We use `execFileSync`
+ * (not `which`/`where.exe`) so the check follows the exact PATH lookup any
+ * subsequent git invocation will use -- that way we never report "found"
+ * when the real call would fail with ENOENT, and vice versa.
+ */
+export declare function probeGit(): GitProbe;
+/**
+ * Build a beginner-friendly message explaining how to recover from a missing
+ * git binary. Includes a Windows-specific hint because the most common
+ * scenario there is "winget install Git.Git just succeeded but this shell's
+ * PATH was cached at launch" -- restarting the shell fixes it without a
+ * second install attempt.
+ */
+export declare function buildMissingGitMessage(commandName: string): string;
+/**
+ * Convenience wrapper for command entry points: probe git, and if it's
+ * missing, print the beginner-friendly message and exit with code 1.
+ * Returns void on success so callers can early-return on failure.
+ */
+export declare function requireGit(commandName: string): void;

package/dist/git/preflight.js

@@ -0,0 +1,50 @@
+import { execFileSync } from 'child_process';
+/**
+ * Probe whether `git` is callable from this process. We use `execFileSync`
+ * (not `which`/`where.exe`) so the check follows the exact PATH lookup any
+ * subsequent git invocation will use -- that way we never report "found"
+ * when the real call would fail with ENOENT, and vice versa.
+ */
+export function probeGit() {
+    try {
+        const out = execFileSync('git', ['--version'], { stdio: ['ignore', 'pipe', 'pipe'] });
+        return { installed: true, version: out.toString('utf-8').trim() };
+    }
+    catch (err) {
+        return { installed: false, error: err };
+    }
+}
+/**
+ * Build a beginner-friendly message explaining how to recover from a missing
+ * git binary. Includes a Windows-specific hint because the most common
+ * scenario there is "winget install Git.Git just succeeded but this shell's
+ * PATH was cached at launch" -- restarting the shell fixes it without a
+ * second install attempt.
+ */
+export function buildMissingGitMessage(commandName) {
+    const lines = [
+        `Git is required to run \`runwork ${commandName}\`, but it was not found on PATH.`,
+        '',
+        'Install Git, then re-run this command:',
+        '  - macOS:   brew install git    (or: xcode-select --install)',
+        '  - Windows: winget install --id Git.Git -e',
+        '  - Linux:   sudo apt-get install -y git    (or your distro\'s equivalent)',
+    ];
+    if (process.platform === 'win32') {
+        lines.push('', 'If you just installed Git, this shell\'s PATH was cached when it opened', 'and does not yet include Git. Close this PowerShell / Command Prompt', 'window, open a fresh one, and re-run the command.');
+    }
+    lines.push('', 'Verify the install with: git --version');
+    return lines.join('\n');
+}
+/**
+ * Convenience wrapper for command entry points: probe git, and if it's
+ * missing, print the beginner-friendly message and exit with code 1.
+ * Returns void on success so callers can early-return on failure.
+ */
+export function requireGit(commandName) {
+    const probe = probeGit();
+    if (probe.installed)
+        return;
+    console.error(buildMissingGitMessage(commandName));
+    process.exit(1);
+}

package/dist/git/sync.js

@@ -147,7 +147,9 @@ export function syncWithRemote(cwd) {
     }
     let pushed = false;
     try {
-        execFileSync('git', ['push', 'runwork', 'main'], { cwd, stdio: 'pipe' });
+        // `HEAD:main` so the push works regardless of local branch name
+        // (older Git defaults to `master`, some users keep custom defaults).
+        execFileSync('git', ['push', 'runwork', 'HEAD:main'], { cwd, stdio: 'pipe' });
         pushed = true;
     }
     catch {

package/dist/health/__tests__/cli-distribution-checks.test.js

@@ -1,12 +1,29 @@
 /**
  * Tests for the first-party distribution checks added to runwork doctor.
  *
- * These checks rely on fetch() to hit https://runwork.ai/cli/latest.json.
- * We stub globalThis.fetch to redirect those calls to a local HTTP server
- * so the suite has no outbound network dependency.
+ * These checks rely on `httpFetch` (our node:https-backed fetch wrapper) to
+ * hit https://runwork.ai/cli/latest.json. We mock the wrapper to redirect
+ * those calls to a local HTTP server so the suite has no outbound network
+ * dependency. We still exercise the real wrapper end to end -- only the
+ * URL is rewritten -- so this remains an integration test of the network
+ * code path.
  */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import { createServer } from 'node:http';
+let currentRedirectBase = null;
+vi.mock('../../utils/http.js', async () => {
+    const actual = await vi.importActual('../../utils/http.js');
+    return {
+        ...actual,
+        httpFetch: (url, init) => {
+            if (currentRedirectBase && url.startsWith('https://runwork.ai')) {
+                const redirected = url.replace('https://runwork.ai', currentRedirectBase);
+                return actual.httpFetch(redirected, init);
+            }
+            return actual.httpFetch(url, init);
+        },
+    };
+});
 import { checkCliVersion, checkCliArtifactReachable, checkCliInstallLocation, } from '../checks.js';
 function startServer() {
     return new Promise((resolvePromise) => {
@@ -56,33 +73,14 @@ function startServer() {
         });
     });
 }
-/**
- * Redirect fetch calls to https://runwork.ai/... at the real test server.
- * Returns a restore function.
- */
-function redirectFetch(baseUrl) {
-    const realFetch = globalThis.fetch;
-    globalThis.fetch = ((input, init) => {
-        const href = typeof input === 'string' ? input : input.toString();
-        if (href.startsWith('https://runwork.ai')) {
-            const redirected = href.replace('https://runwork.ai', baseUrl);
-            return realFetch(redirected, init);
-        }
-        return realFetch(input, init);
-    });
-    return () => {
-        globalThis.fetch = realFetch;
-    };
-}
 describe('checkCliVersion (runwork.ai backed)', () => {
     let server;
-    let restoreFetch;
     beforeEach(async () => {
         server = await startServer();
-        restoreFetch = redirectFetch(server.url);
+        currentRedirectBase = server.url;
     });
     afterEach(async () => {
-        restoreFetch();
+        currentRedirectBase = null;
         await server.stop();
     });
     it('skips with an explicit unreachable message when the manifest 404s', async () => {
@@ -117,13 +115,12 @@ describe('checkCliVersion (runwork.ai backed)', () => {
 });
 describe('checkCliArtifactReachable', () => {
     let server;
-    let restoreFetch;
     beforeEach(async () => {
         server = await startServer();
-        restoreFetch = redirectFetch(server.url);
+        currentRedirectBase = server.url;
     });
     afterEach(async () => {
-        restoreFetch();
+        currentRedirectBase = null;
         await server.stop();
     });
     function platformKey() {

package/dist/health/checks.js

@@ -6,6 +6,7 @@ import { VERSION } from '../generated/version.js';
 import { getCredentials } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
 import { detectAgents, getAdapterBySlug } from '../agents/detect.js';
+import { httpFetch } from '../utils/http.js';
 // First-party distribution endpoints. Defaults match the plan, can be
 // overridden via RUNWORK_DOWNLOAD_BASE_URL for staging or debugging.
 const BASE_URL = process.env.RUNWORK_DOWNLOAD_BASE_URL || 'https://runwork.ai';
@@ -23,7 +24,7 @@ function detectPlatform() {
 }
 async function fetchReleaseManifest() {
     try {
-        const response = await fetch(LATEST_JSON_URL, { cache: 'no-store' });
+        const response = await httpFetch(LATEST_JSON_URL, { cache: 'no-store' });
         if (!response.ok)
             return null;
         return await response.json();
@@ -123,7 +124,7 @@ export async function checkCliArtifactReachable() {
     }
     const artifactUrl = `${BASE_URL}${entry.path}`;
     try {
-        const response = await fetch(artifactUrl, { method: 'HEAD' });
+        const response = await httpFetch(artifactUrl, { method: 'HEAD' });
         if (!response.ok) {
             return {
                 name: 'cli-artifact',

package/dist/index.js

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
+import { formatError } from './utils/format-error.js';
 import { loginCommand } from './commands/login.js';
 import { initCommand } from './commands/init.js';
 import { cloneCommand } from './commands/clone.js';
@@ -30,6 +31,20 @@ import { handleGitCredentialRequest } from './git/credentials.js';
 import { VERSION } from './generated/version.js';
 import { shouldOutputJson, jsonOut } from './utils/output.js';
 import { buildHelpJson, buildCommandHelpJson } from './utils/help-json.js';
+// Surface escaped errors and rejections instead of letting the process exit
+// silently. Without these handlers, an unhandled rejection inside a Commander
+// async action vanishes on the bun-compiled Windows binary -- the user sees
+// only the last `console.log` we managed to flush before the runtime tore
+// the program down. Both handlers are deliberately strict (exit 1) so the
+// failure is visible in CI / wrappers like the desktop app.
+process.on('unhandledRejection', (reason) => {
+    console.error(`Unhandled rejection: ${formatError(reason)}`);
+    process.exit(1);
+});
+process.on('uncaughtException', (err) => {
+    console.error(`Uncaught exception: ${formatError(err)}`);
+    process.exit(1);
+});
 const program = new Command();
 program
     .name('runwork')
@@ -115,4 +130,20 @@ if (!hasCommand && !isHelpOrVersion && args.length === 0) {
         process.exit(0);
     }
 }
-program.parse();
+// IMPORTANT: use parseAsync, not parse. Many of our actions are async and
+// the bun-compiled Windows binary will exit before pending promises resolve
+// when we don't await the returned promise -- that manifests as a silent
+// abort partway through `runwork clone`, `dev`, etc. with no error output.
+//
+// Call with NO arguments so Commander reads `process.argv` itself with its
+// `'auto'` detection. Passing `process.argv` explicitly defaults to the
+// `'node'` parse mode and strips the wrong elements when this is run as a
+// bun-compiled standalone binary (where there is no separate "script" argv
+// slot), making every command silently fail to match.
+try {
+    await program.parseAsync();
+}
+catch (err) {
+    console.error(formatError(err));
+    process.exit(1);
+}

package/dist/utils/__tests__/format-error.test.d.ts

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

package/dist/utils/__tests__/format-error.test.js

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+import { formatError } from '../format-error.js';
+describe('formatError', () => {
+    it('handles plain Error objects', () => {
+        expect(formatError(new Error('boom'))).toBe('boom');
+    });
+    it('returns "unknown error" for null/undefined', () => {
+        expect(formatError(null)).toBe('unknown error');
+        expect(formatError(undefined)).toBe('unknown error');
+    });
+    it('extracts stderr buffer from execFileSync-style errors', () => {
+        const err = Object.assign(new Error('Command failed: git fetch'), {
+            stderr: Buffer.from('fatal: could not read Username\n'),
+        });
+        expect(formatError(err)).toContain('fatal: could not read Username');
+    });
+    it('extracts stderr string when not a buffer', () => {
+        const err = Object.assign(new Error('Command failed'), {
+            stderr: '  fatal: bad ref  ',
+        });
+        expect(formatError(err)).toContain('fatal: bad ref');
+    });
+    it('falls back to stdout when stderr is empty', () => {
+        const err = Object.assign(new Error('Command failed'), {
+            stderr: '',
+            stdout: Buffer.from('CONFLICT (content): merge conflict in foo'),
+        });
+        expect(formatError(err)).toContain('CONFLICT');
+    });
+    it('prefixes with errno code when available', () => {
+        const err = Object.assign(new Error('spawn git ENOENT'), {
+            code: 'ENOENT',
+            stderr: 'spawn git ENOENT',
+        });
+        const out = formatError(err);
+        expect(out).toMatch(/^ENOENT:/);
+        expect(out).toContain('spawn git ENOENT');
+    });
+    it('coerces non-Error values to strings', () => {
+        expect(formatError('a plain string')).toBe('a plain string');
+        expect(formatError(42)).toBe('42');
+    });
+});

package/dist/utils/__tests__/http.test.d.ts

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