runwork 0.9.4 → 0.10.1

package/dist/commands/endpoints.js

@@ -3,6 +3,7 @@ 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 { httpFetch } from '../utils/http.js';
 function truncate(text, max) {
     if (!text)
         return '';
@@ -137,7 +138,7 @@ const callCommand = new Command('call')
         else {
             console.log(`\n${targetMethod} ${url}\n`);
         }
-        const response = await fetch(url, {
+        const response = await httpFetch(url, {
             method: targetMethod,
             headers,
             body,

package/dist/commands/files.js

@@ -6,6 +6,7 @@ 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 { httpFetch } from '../utils/http.js';
 function formatSize(bytes) {
     if (bytes === undefined)
         return '';
@@ -106,7 +107,7 @@ const downloadCommand = new Command('download')
     const outputPath = output || basename(key);
     try {
         const { url } = await client.getPresignedUrl(workspaceId, bucket, { action: 'read', key });
-        const response = await fetch(url);
+        const response = await httpFetch(url);
         if (!response.ok) {
             throw new Error(`Download failed: ${response.status} ${response.statusText}`);
         }
@@ -137,7 +138,7 @@ const uploadCommand = new Command('upload')
     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 });
+        const response = await httpFetch(url, { method: 'PUT', body: fileBuffer });
         if (!response.ok) {
             throw new Error(`Upload failed: ${response.status} ${response.statusText}`);
         }

package/dist/commands/info.d.ts

@@ -1,3 +1,144 @@
 import { Command } from 'commander';
+import type { WorkspaceAllData } from '../types.js';
+interface BlueprintEntity {
+    entityName: string;
+    schema?: Record<string, unknown>;
+}
+interface BlueprintSchedule {
+    name: string;
+    schedule?: string;
+    description?: string;
+}
+interface BlueprintWorkflow {
+    name: string;
+    description?: string;
+}
+interface BlueprintAgent {
+    name: string;
+    type?: string;
+    description?: string;
+}
+interface BlueprintEndpoint {
+    path: string;
+    method?: string;
+    description?: string;
+}
+interface BlueprintComponent {
+    componentName: string;
+}
+interface Blueprint {
+    entities?: BlueprintEntity[];
+    schedules?: BlueprintSchedule[];
+    scheduledJobs?: BlueprintSchedule[];
+    workflows?: BlueprintWorkflow[];
+    agents?: BlueprintAgent[];
+    endpoints?: BlueprintEndpoint[];
+    publicEndpoints?: BlueprintEndpoint[];
+    components?: BlueprintComponent[];
+    fileStorage?: boolean | {
+        enabled?: boolean;
+    };
+}
+interface MergedEntity {
+    name: string;
+    sources: string[];
+    schema?: Record<string, unknown>;
+}
+interface MergedScheduledJob {
+    name: string;
+    sources: string[];
+    schedule?: string;
+    description?: string;
+}
+interface MergedWorkflow {
+    name: string;
+    sources: string[];
+    description?: string;
+}
+interface MergedAgent {
+    name: string;
+    sources: string[];
+    type?: string;
+    description?: string;
+}
+interface MergedEndpoint {
+    path: string;
+    method?: string;
+    sources: string[];
+    description?: string;
+}
+interface MergedComponent {
+    name: string;
+    sources: string[];
+}
+interface MergedFileStorage {
+    enabled: boolean;
+    sources: string[];
+}
+interface InfoOutput {
+    app: {
+        id: string;
+        name: string;
+        slug: string;
+    } | null;
+    workspace: {
+        id: string;
+        name: string;
+    };
+    preview: {
+        url: string | null;
+        active: boolean;
+    };
+    production: {
+        url: null;
+        deployed: boolean;
+    };
+    integrations: Array<{
+        id: string;
+        status: string;
+    }> | null;
+    registries: {
+        entities: MergedEntity[];
+        workflows: MergedWorkflow[];
+        scheduledJobs: MergedScheduledJob[];
+        agents: MergedAgent[];
+        publicEndpoints: MergedEndpoint[];
+        components: MergedComponent[];
+        fileStorage: MergedFileStorage;
+    } | null;
+    cli: {
+        version: string;
+        commands: Array<{
+            name: string;
+            description: string;
+        }>;
+    };
+}
+interface ServerRegistryItem {
+    appId: string;
+    appName: string;
+    deploymentMode?: 'preview' | 'production';
+}
+declare function mergeSources<T extends ServerRegistryItem>(blueprintItems: Array<{
+    name: string;
+    extra?: Record<string, unknown>;
+}>, serverItems: T[], getServerName: (item: T) => string, appId: string): Map<string, {
+    sources: string[];
+    serverItem?: T;
+    blueprintExtra?: Record<string, unknown>;
+}>;
+declare function buildRegistries(blueprint: Blueprint | null, serverData: WorkspaceAllData | null, appId: string): InfoOutput['registries'];
+/**
+ * Pad a possibly-missing string to a fixed width. Returns a visible
+ * placeholder when the value isn't a usable string so the human-readable
+ * printer can never crash on an unexpectedly-undefined field.
+ */
+declare function padName(value: unknown, width: number): string;
 export declare function formatSources(sources: string[]): string;
+export declare const __testing: {
+    mergeSources: typeof mergeSources;
+    padName: typeof padName;
+    buildRegistries: typeof buildRegistries;
+};
 export declare const infoCommand: Command;
+export {};

package/dist/commands/info.js

@@ -32,13 +32,22 @@ function readBlueprint(cwd) {
 }
 function mergeSources(blueprintItems, serverItems, getServerName, appId) {
     const map = new Map();
+    // Skip nameless entries so we never store an `undefined` key. A bad
+    // blueprint or a partially-populated server-side row would otherwise
+    // produce a registry entry with `name === undefined`, which then crashes
+    // the human-readable printer at `a.name.padEnd(24)` and yields ugly
+    // `"undefined": ...` keys in JSON output.
     for (const bp of blueprintItems) {
+        if (typeof bp.name !== 'string' || bp.name.length === 0)
+            continue;
         map.set(bp.name, { sources: ['blueprint'], blueprintExtra: bp.extra });
     }
     for (const serverItem of serverItems) {
         if (serverItem.appId !== appId)
             continue;
         const name = getServerName(serverItem);
+        if (typeof name !== 'string' || name.length === 0)
+            continue;
         const mode = serverItem.deploymentMode;
         const source = mode === 'production' ? 'production' : 'preview';
         const existing = map.get(name);
@@ -171,6 +180,16 @@ function getCliCommands(command) {
         return { name, description: cmd.description() };
     });
 }
+/**
+ * Pad a possibly-missing string to a fixed width. Returns a visible
+ * placeholder when the value isn't a usable string so the human-readable
+ * printer can never crash on an unexpectedly-undefined field.
+ */
+function padName(value, width) {
+    if (typeof value === 'string' && value.length > 0)
+        return value.padEnd(width);
+    return '(unnamed)'.padEnd(width);
+}
 export function formatSources(sources) {
     return sources
         .map(s => {
@@ -240,7 +259,7 @@ function printHumanOutput(data) {
             if (reg.entities.length > 0) {
                 console.log(`  ${bold('Entities:')}`);
                 for (const e of reg.entities) {
-                    console.log(`    ${e.name.padEnd(24)} ${formatSources(e.sources)}`);
+                    console.log(`    ${padName(e.name, 24)} ${formatSources(e.sources)}`);
                 }
                 console.log('');
             }
@@ -248,7 +267,7 @@ function printHumanOutput(data) {
                 console.log(`  ${bold('Workflows:')}`);
                 for (const w of reg.workflows) {
                     const desc = w.description ? `  ${dim(w.description)}` : '';
-                    console.log(`    ${w.name.padEnd(24)} ${formatSources(w.sources)}${desc}`);
+                    console.log(`    ${padName(w.name, 24)} ${formatSources(w.sources)}${desc}`);
                 }
                 console.log('');
             }
@@ -256,7 +275,7 @@ function printHumanOutput(data) {
                 console.log(`  ${bold('Scheduled Jobs:')}`);
                 for (const s of reg.scheduledJobs) {
                     const schedule = s.schedule ? `  ${gray(s.schedule)}` : '';
-                    console.log(`    ${s.name.padEnd(24)} ${formatSources(s.sources)}${schedule}`);
+                    console.log(`    ${padName(s.name, 24)} ${formatSources(s.sources)}${schedule}`);
                 }
                 console.log('');
             }
@@ -264,22 +283,22 @@ function printHumanOutput(data) {
                 console.log(`  ${bold('Agents:')}`);
                 for (const a of reg.agents) {
                     const type = a.type ? `  ${dim(a.type)}` : '';
-                    console.log(`    ${a.name.padEnd(24)} ${formatSources(a.sources)}${type}`);
+                    console.log(`    ${padName(a.name, 24)} ${formatSources(a.sources)}${type}`);
                 }
                 console.log('');
             }
             if (reg.publicEndpoints.length > 0) {
                 console.log(`  ${bold('Public Endpoints:')}`);
                 for (const e of reg.publicEndpoints) {
-                    const label = e.method ? `${e.method} ${e.path}` : e.path;
-                    console.log(`    ${label.padEnd(24)} ${formatSources(e.sources)}`);
+                    const label = e.method && e.path ? `${e.method} ${e.path}` : (e.path || '');
+                    console.log(`    ${padName(label, 24)} ${formatSources(e.sources)}`);
                 }
                 console.log('');
             }
             if (reg.components.length > 0) {
                 console.log(`  ${bold('Components:')}`);
                 for (const c of reg.components) {
-                    console.log(`    ${c.name.padEnd(24)} ${formatSources(c.sources)}`);
+                    console.log(`    ${padName(c.name, 24)} ${formatSources(c.sources)}`);
                 }
                 console.log('');
             }
@@ -298,6 +317,9 @@ function printHumanOutput(data) {
     console.log(dim(`  CLI version: ${data.cli.version}`));
     console.log('');
 }
+// Internal helpers exposed for unit tests; do not import from anywhere
+// other than `__tests__/`.
+export const __testing = { mergeSources, padName, buildRegistries };
 export const infoCommand = new Command('info')
     .description('Show app context, registries, and CLI reference (use --json for agent discovery)')
     .action(async (_opts, command) => {

package/dist/commands/init.d.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander';
 import { ApiClient } from '../api/client.js';
-import type { WorkspaceInfo } from '../types.js';
+import type { Credentials, WorkspaceInfo } from '../types.js';
 export interface InitResult {
     appId: string;
     appName: string;
@@ -15,7 +15,7 @@ export interface ExecInitOptions {
 }
 /** Default parent directory for new apps when --here is not passed. */
 export declare const DEFAULT_APPS_DIR: string;
-export declare function execInit(client: ApiClient, appName: string, workspace: WorkspaceInfo, options?: ExecInitOptions): Promise<InitResult>;
+export declare function execInit(client: ApiClient, appName: string, workspace: WorkspaceInfo, options?: ExecInitOptions, creds?: Credentials | null): Promise<InitResult>;
 /** Full create flow: prompt for name/workspace, init, and run agent wizard */
 export declare function runCreateFlow(name?: string, workspaceFlag?: string, options?: ExecInitOptions): Promise<void>;
 export declare const initCommand: Command;

package/dist/commands/init.js

@@ -5,6 +5,9 @@ import { join, resolve } from 'path';
 import { homedir } from 'os';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';
+import { ensureGitIdentity } from '../git/identity.js';
+import { requireGit } from '../git/preflight.js';
+import { formatError } from '../utils/format-error.js';
 import { promptSelect, promptInput } from '../utils/prompt.js';
 import { resolveWorkspace } from '../utils/resolve.js';
 import { generateManifest, saveManifest } from '../template/manifest.js';
@@ -15,7 +18,7 @@ import { shouldOutputJson, jsonOut } from '../utils/output.js';
 import { buildInitGuide, buildErrorResponse } from '../utils/agent-guidance.js';
 /** Default parent directory for new apps when --here is not passed. */
 export const DEFAULT_APPS_DIR = join(homedir(), '.runwork', 'apps');
-export async function execInit(client, appName, workspace, options = {}) {
+export async function execInit(client, appName, workspace, options = {}, creds) {
     const app = await client.initApp(workspace.id, appName);
     const slug = app.slug || appName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
     const parentDir = options.here ? process.cwd() : DEFAULT_APPS_DIR;
@@ -54,10 +57,29 @@ export async function execInit(client, appName, workspace, options = {}) {
         appName: app.name,
     };
     writeFileSync(join(dir, '.runwork.json'), JSON.stringify(config, null, 2));
-    // Initialize git
+    // Initialize git. `stdio: 'pipe'` swallows git's stderr, so we have to
+    // print any failure ourselves -- otherwise this fails silently and the
+    // user is left with an empty directory and no clue what happened.
     if (!existsSync(join(dir, '.git'))) {
-        execFileSync('git', ['init'], { cwd: dir, stdio: 'pipe' });
+        try {
+            execFileSync('git', ['init'], { cwd: dir, stdio: 'pipe' });
+        }
+        catch (err) {
+            console.error(`git init failed in ${dir}: ${formatError(err)}`);
+            throw err;
+        }
+        // Force the initial branch to `main` regardless of the user's
+        // `init.defaultBranch` config (older Git installs default to
+        // `master`). symbolic-ref works before any commits exist; `git
+        // branch -M main` would not.
+        try {
+            execFileSync('git', ['symbolic-ref', 'HEAD', 'refs/heads/main'], { cwd: dir, stdio: 'pipe' });
+        }
+        catch { /* best-effort: push uses HEAD:main so this is just cleanliness */ }
     }
+    // Seed a local git identity so the initial commit cannot fail on machines
+    // (commonly fresh Windows installs) without `git config --global user.email`.
+    ensureGitIdentity(dir, creds);
     // Add runwork remote
     const remoteUrl = client.getGitRemoteUrl(workspace.id, app.id);
     try {
@@ -78,7 +100,13 @@ export async function execInit(client, appName, workspace, options = {}) {
     catch {
         // Nothing to commit is fine
     }
-    execFileSync('git', ['push', '-u', 'runwork', 'main'], { cwd: dir, stdio: 'pipe' });
+    try {
+        execFileSync('git', ['push', '-u', 'runwork', 'main'], { cwd: dir, stdio: 'pipe' });
+    }
+    catch (err) {
+        console.error(`git push to runwork remote failed: ${formatError(err)}`);
+        throw err;
+    }
     console.log(`\nApp "${app.name}" initialized in ${dir}`);
     return {
         appId: app.id,
@@ -92,6 +120,7 @@ export async function execInit(client, appName, workspace, options = {}) {
 /** Full create flow: prompt for name/workspace, init, and run agent wizard */
 export async function runCreateFlow(name, workspaceFlag, options = {}) {
     const useJson = shouldOutputJson(undefined);
+    requireGit('init');
     const creds = requireAuth();
     const client = new ApiClient(creds);
     const appName = name || await promptInput('App name');
@@ -132,7 +161,7 @@ export async function runCreateFlow(name, workspaceFlag, options = {}) {
     if (!useJson) {
         console.log(`Creating "${appName}" in workspace "${workspace.name}"...`);
     }
-    const initResult = await execInit(client, appName, workspace, options);
+    const initResult = await execInit(client, appName, workspace, options, creds);
     if (useJson) {
         const response = {
             success: true,

package/dist/commands/upgrade.js

@@ -4,13 +4,14 @@ import { platform as osPlatform, tmpdir } from 'os';
 import { mkdtempSync, writeFileSync, rmSync } from 'fs';
 import { join } from 'path';
 import { VERSION } from '../generated/version.js';
+import { httpFetch } from '../utils/http.js';
 const BASE_URL = 'https://runwork.ai';
 const LATEST_JSON_URL = `${BASE_URL}/cli/latest.json`;
 const INSTALL_SH_URL = `${BASE_URL}/install.sh`;
 const INSTALL_PS1_URL = `${BASE_URL}/install.ps1`;
 async function fetchLatestVersion() {
     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;
         const data = await response.json();
@@ -57,7 +58,7 @@ async function upgradeBinary() {
     const isWindows = osPlatform() === 'win32';
     if (isWindows) {
         console.log('\nUpgrading via PowerShell installer...\n');
-        const response = await fetch(INSTALL_PS1_URL, { cache: 'no-store' });
+        const response = await httpFetch(INSTALL_PS1_URL, { cache: 'no-store' });
         if (!response.ok) {
             throw new Error(`Failed to download install.ps1: HTTP ${response.status}`);
         }
@@ -83,7 +84,7 @@ async function upgradeBinary() {
         return;
     }
     console.log('\nUpgrading via install.sh...\n');
-    const response = await fetch(INSTALL_SH_URL, { cache: 'no-store' });
+    const response = await httpFetch(INSTALL_SH_URL, { cache: 'no-store' });
     if (!response.ok) {
         throw new Error(`Failed to download install.sh: HTTP ${response.status}`);
     }

package/dist/commands/welcome.js

@@ -51,7 +51,7 @@ export async function runWelcomeWizard() {
         console.log('');
         console.log(`Creating ${cyan(appName)} in workspace ${cyan(workspace.name)}...`);
         const { execInit } = await import('./init.js');
-        const initResult = await execInit(client, appName, workspace);
+        const initResult = await execInit(client, appName, workspace, {}, creds);
         appDir = initResult.directory;
     }
     else {
@@ -62,7 +62,7 @@ export async function runWelcomeWizard() {
         }
         const choice = await promptSelect('Select app to clone:', apps.map(a => ({ label: `${a.name} (${a.workspaceName})`, value: a })));
         const { execClone } = await import('./clone.js');
-        const cloneResult = await execClone(client, choice.value);
+        const cloneResult = await execClone(client, choice.value, undefined, creds);
         appDir = cloneResult.directory;
     }
     // Step 4: Agent guidance

package/dist/devtools/registry-data.d.ts

@@ -25,6 +25,13 @@ export type DevToolInstallStrategy = {
 export interface DevToolDefinition extends InstallableTool {
     /** Beginner-friendly explanation shown in the install card. */
     longDescription: string;
+    /**
+     * When true, the desktop must block onboarding "Continue" until this tool
+     * is detected (or explicitly skipped only after an attempted install).
+     * Use sparingly: this is reserved for tools whose absence guarantees the
+     * core CLI loop (init / clone / dev / deploy) will fail.
+     */
+    required?: boolean;
     /**
      * Per-platform install strategy. Missing platforms fall back to opening
      * `downloadUrl` in the browser.

package/dist/devtools/registry-data.js

@@ -13,6 +13,7 @@ const DEV_TOOL_REGISTRY = [
         name: 'Git',
         description: 'Version control system',
         longDescription: 'Git tracks changes to your code and is required for Runwork commands that sync your work with the platform (init, clone, dev, deploy).',
+        required: true,
         detection: { method: 'binary', target: 'git' },
         downloadUrl: 'https://git-scm.com/downloads',
         install: {

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.9.4";
+export declare const VERSION = "0.10.1";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/embed-types.ts -- do not edit
-export const VERSION = "0.9.4";
+export const VERSION = "0.10.1";

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

@@ -18,7 +18,7 @@ describe('git/credentials', () => {
                 '--global',
                 'credential.https://runwork.ai.helper',
                 '!runwork git-credential-helper',
-            ]);
+            ], { stdio: 'pipe' });
         });
         it('extracts origin from full URL', async () => {
             await configureGitCredentials('https://custom.runwork.dev/api/git/ws-1/app-1');
@@ -27,7 +27,7 @@ describe('git/credentials', () => {
                 '--global',
                 'credential.https://custom.runwork.dev.helper',
                 '!runwork git-credential-helper',
-            ]);
+            ], { stdio: 'pipe' });
         });
         it('handles URL with port', async () => {
             await configureGitCredentials('https://localhost:8787/api/git/ws/app');
@@ -36,7 +36,7 @@ describe('git/credentials', () => {
                 '--global',
                 'credential.https://localhost:8787.helper',
                 '!runwork git-credential-helper',
-            ]);
+            ], { stdio: 'pipe' });
         });
     });
     describe('removeGitCredentials()', () => {
@@ -47,7 +47,7 @@ describe('git/credentials', () => {
                 '--global',
                 '--unset',
                 'credential.https://runwork.ai.helper',
-            ]);
+            ], { stdio: 'pipe' });
         });
         it('ignores errors silently', async () => {
             mockExecFileSync.mockImplementation(() => {

package/dist/git/__tests__/identity.test.d.ts

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

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

@@ -0,0 +1,146 @@
+import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
+import { execFileSync } from 'child_process';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { ensureGitIdentity, __testing } from '../identity.js';
+const tempDirs = [];
+// Isolate every git invocation in this file from the developer's real
+// `~/.gitconfig` (and any system-level config). Without this, anyone running
+// the suite locally with `git config --global user.email` already set would
+// see the helper short-circuit (correctly) and the "fresh machine" assertions
+// would never exercise the write path. We point GIT_CONFIG_GLOBAL/SYSTEM at
+// paths that don't exist; git treats missing config files as empty.
+const ISOLATION_DIR = mkdtempSync(join(tmpdir(), 'runwork-identity-isolation-'));
+const NON_EXISTENT = join(ISOLATION_DIR, 'no-such-config');
+const PREVIOUS_ENV = {};
+beforeAll(() => {
+    for (const key of ['GIT_CONFIG_GLOBAL', 'GIT_CONFIG_SYSTEM', 'HOME', 'XDG_CONFIG_HOME']) {
+        PREVIOUS_ENV[key] = process.env[key];
+    }
+    process.env.GIT_CONFIG_GLOBAL = NON_EXISTENT;
+    process.env.GIT_CONFIG_SYSTEM = NON_EXISTENT;
+    // Some git builds still consult $HOME/.gitconfig even with GIT_CONFIG_GLOBAL
+    // set. Pointing HOME at the empty isolation directory closes that hole.
+    process.env.HOME = ISOLATION_DIR;
+    process.env.XDG_CONFIG_HOME = ISOLATION_DIR;
+});
+afterAll(() => {
+    for (const [key, value] of Object.entries(PREVIOUS_ENV)) {
+        if (value === undefined)
+            delete process.env[key];
+        else
+            process.env[key] = value;
+    }
+    try {
+        rmSync(ISOLATION_DIR, { recursive: true, force: true });
+    }
+    catch { /* best-effort */ }
+});
+function makeRepo() {
+    const dir = mkdtempSync(join(tmpdir(), 'runwork-identity-test-'));
+    tempDirs.push(dir);
+    execFileSync('git', ['init', dir]);
+    return dir;
+}
+function readConfig(cwd, key) {
+    try {
+        return execFileSync('git', ['config', '--local', '--get', key], { cwd }).toString('utf-8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+afterEach(() => {
+    for (const dir of tempDirs) {
+        try {
+            rmSync(dir, { recursive: true, force: true });
+        }
+        catch { /* best-effort */ }
+    }
+    tempDirs.length = 0;
+});
+describe('deriveNameFromEmail', () => {
+    it('uppercases the local part', () => {
+        expect(__testing.deriveNameFromEmail('oytun@motaword.com')).toBe('Oytun');
+    });
+    it('splits separators into words', () => {
+        expect(__testing.deriveNameFromEmail('anna.maria@example.com')).toBe('Anna Maria');
+        expect(__testing.deriveNameFromEmail('jean-luc@example.com')).toBe('Jean Luc');
+        expect(__testing.deriveNameFromEmail('user_name@example.com')).toBe('User Name');
+    });
+    it('falls back to default when local part is empty', () => {
+        expect(__testing.deriveNameFromEmail('@example.com')).toBe(__testing.FALLBACK_NAME);
+    });
+});
+describe('pickIdentity', () => {
+    it('uses the credentials email when it looks like an email', () => {
+        expect(__testing.pickIdentity({ apiKey: 'k', email: 'oytun@motaword.com', baseUrl: '' }))
+            .toEqual({ email: 'oytun@motaword.com', name: 'Oytun' });
+    });
+    it('falls back when email is the api-key-auth placeholder', () => {
+        expect(__testing.pickIdentity({ apiKey: 'k', email: 'api-key-auth', baseUrl: '' }))
+            .toEqual({ email: __testing.FALLBACK_EMAIL, name: __testing.FALLBACK_NAME });
+    });
+    it('falls back when no credentials are passed', () => {
+        expect(__testing.pickIdentity(null))
+            .toEqual({ email: __testing.FALLBACK_EMAIL, name: __testing.FALLBACK_NAME });
+    });
+});
+describe('ensureGitIdentity', () => {
+    it('writes local user.email and user.name when none are configured', () => {
+        const dir = makeRepo();
+        expect(readConfig(dir, 'user.email')).toBe('');
+        expect(readConfig(dir, 'user.name')).toBe('');
+        ensureGitIdentity(dir, { apiKey: 'k', email: 'oytun@motaword.com', baseUrl: '' });
+        expect(readConfig(dir, 'user.email')).toBe('oytun@motaword.com');
+        expect(readConfig(dir, 'user.name')).toBe('Oytun');
+    });
+    it('overwrites local config with Runwork credentials when they are usable', () => {
+        // Commits to a Runwork remote should always be attributed to the
+        // authenticated Runwork user, even if the developer set a local identity
+        // earlier (e.g. a stale value from a previous account).
+        const dir = makeRepo();
+        execFileSync('git', ['config', '--local', 'user.email', 'preset@example.com'], { cwd: dir });
+        execFileSync('git', ['config', '--local', 'user.name', 'Preset User'], { cwd: dir });
+        ensureGitIdentity(dir, { apiKey: 'k', email: 'oytun@motaword.com', baseUrl: '' });
+        expect(readConfig(dir, 'user.email')).toBe('oytun@motaword.com');
+        expect(readConfig(dir, 'user.name')).toBe('Oytun');
+    });
+    it('respects existing local config when no Runwork credentials are available', () => {
+        // Without a real Runwork identity to attribute the commit to, leave any
+        // pre-existing local identity (or anything inherited from --global) alone.
+        const dir = makeRepo();
+        execFileSync('git', ['config', '--local', 'user.email', 'preset@example.com'], { cwd: dir });
+        execFileSync('git', ['config', '--local', 'user.name', 'Preset User'], { cwd: dir });
+        ensureGitIdentity(dir, null);
+        expect(readConfig(dir, 'user.email')).toBe('preset@example.com');
+        expect(readConfig(dir, 'user.name')).toBe('Preset User');
+    });
+    it('respects existing local config when credentials carry only a placeholder email', () => {
+        const dir = makeRepo();
+        execFileSync('git', ['config', '--local', 'user.email', 'preset@example.com'], { cwd: dir });
+        execFileSync('git', ['config', '--local', 'user.name', 'Preset User'], { cwd: dir });
+        ensureGitIdentity(dir, { apiKey: 'k', email: 'api-key-auth', baseUrl: '' });
+        expect(readConfig(dir, 'user.email')).toBe('preset@example.com');
+        expect(readConfig(dir, 'user.name')).toBe('Preset User');
+    });
+    it('falls back to a synthetic identity when credentials are missing', () => {
+        const dir = makeRepo();
+        ensureGitIdentity(dir, null);
+        expect(readConfig(dir, 'user.email')).toBe(__testing.FALLBACK_EMAIL);
+        expect(readConfig(dir, 'user.name')).toBe(__testing.FALLBACK_NAME);
+    });
+    it('lets a real commit succeed on a fresh repo (windows-style "no identity" path)', () => {
+        const dir = makeRepo();
+        ensureGitIdentity(dir, { apiKey: 'k', email: 'oytun@motaword.com', baseUrl: '' });
+        execFileSync('git', ['commit', '--allow-empty', '-m', 'identity probe'], { cwd: dir, stdio: 'pipe' });
+        const log = execFileSync('git', ['log', '--pretty=%an <%ae>'], { cwd: dir }).toString('utf-8').trim();
+        expect(log).toContain('Oytun <oytun@motaword.com>');
+    });
+    it('is a no-op for non-git directories', () => {
+        const dir = mkdtempSync(join(tmpdir(), 'runwork-identity-non-git-'));
+        tempDirs.push(dir);
+        expect(() => ensureGitIdentity(dir, null)).not.toThrow();
+    });
+});

package/dist/git/__tests__/preflight.test.d.ts

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