runwork 0.15.0 → 0.15.2

package/dist/commands/workflows.js

@@ -1,187 +0,0 @@
-import { Command } from 'commander';
-import { requireAuth } from '../auth/store.js';
-import { ApiClient } from '../api/client.js';
-import { resolveWorkspace, resolveApp } from '../workspace/resolve.js';
-import { shouldOutputJson, jsonOut } from '../utils/output.js';
-function truncate(text, max) {
-    if (!text)
-        return '';
-    const first = text.split('\n')[0];
-    if (first.length <= max)
-        return first;
-    return first.slice(0, max - 3) + '...';
-}
-const listCommand = new Command('list')
-    .description('List workflows in a workspace')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--app <name>', 'Filter by app name or ID')
-    .action(async (opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId, workspaceName } = await resolveWorkspace(client, opts);
-    try {
-        let workflows = await client.listWorkflows(workspaceId);
-        if (opts.app) {
-            workflows = workflows.filter(w => w.appId === opts.app || w.appName === opts.app);
-        }
-        if (useJson) {
-            jsonOut({ workflows });
-            return;
-        }
-        if (workflows.length === 0) {
-            console.log('No workflows found.');
-            return;
-        }
-        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
-        console.log('  ' +
-            'Name'.padEnd(24) +
-            'App'.padEnd(20) +
-            'Mode'.padEnd(12) +
-            'Enabled'.padEnd(10) +
-            'Description');
-        console.log('  ' + '-'.repeat(80));
-        for (const w of workflows) {
-            const mode = w.deploymentMode ?? '';
-            const enabled = w.enabled === false ? 'no' : 'yes';
-            console.log('  ' +
-                w.name.padEnd(24) +
-                (w.appName || w.appId).slice(0, 18).padEnd(20) +
-                mode.padEnd(12) +
-                enabled.padEnd(10) +
-                truncate(w.description, 40));
-        }
-        console.log('');
-    }
-    catch (err) {
-        console.error('Failed to list workflows:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const triggerCommand = new Command('trigger')
-    .description('Trigger a workflow by name')
-    .argument('<name>', 'Workflow name')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--app <name>', 'App name or ID (required if not in a project directory)')
-    .option('--params <json>', 'JSON string of parameters to pass to the workflow')
-    .option('--instance-id <id>', 'Custom instance ID for the workflow run')
-    .action(async (name, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    const { appId, appName } = await resolveApp(client, workspaceId, opts);
-    let params;
-    if (opts.params) {
-        try {
-            params = JSON.parse(opts.params);
-        }
-        catch {
-            console.error('Failed to parse --params: must be valid JSON');
-            process.exit(1);
-        }
-    }
-    try {
-        const result = await client.triggerWorkflow(workspaceId, {
-            workflowName: name,
-            appId,
-            params,
-            instanceId: opts.instanceId,
-        });
-        if (useJson) {
-            jsonOut({ result });
-            return;
-        }
-        console.log(`Triggered workflow "${name}" on app "${appName || appId}".`);
-        console.log(`  Instance ID: ${result.instanceId}`);
-        console.log(`  Status:      ${result.status}`);
-    }
-    catch (err) {
-        console.error('Failed to trigger workflow:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const instancesCommand = new Command('instances')
-    .description('List workflow instances for an app')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--app <name>', 'App name or ID (required if not in a project directory)')
-    .option('--workflow <name>', 'Filter by workflow name')
-    .option('--status <status>', 'Filter by instance status')
-    .option('--limit <n>', 'Maximum number of instances to return')
-    .action(async (opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    const { appId } = await resolveApp(client, workspaceId, opts);
-    try {
-        const data = await client.listWorkflowInstances(workspaceId, appId, {
-            workflowName: opts.workflow,
-            status: opts.status,
-            limit: opts.limit !== undefined ? Number(opts.limit) : undefined,
-        });
-        if (useJson) {
-            jsonOut({ instances: data.instances });
-            return;
-        }
-        if (data.instances.length === 0) {
-            console.log('No workflow instances found.');
-            return;
-        }
-        console.log('\n  ' +
-            'ID'.padEnd(28) +
-            'Workflow'.padEnd(24) +
-            'Status'.padEnd(14) +
-            'Created At');
-        console.log('  ' + '-'.repeat(80));
-        for (const inst of data.instances) {
-            const created = inst.createdAt
-                ? new Date(inst.createdAt).toLocaleString()
-                : '';
-            console.log('  ' +
-                inst.id.slice(0, 26).padEnd(28) +
-                inst.workflowName.padEnd(24) +
-                inst.status.padEnd(14) +
-                created);
-        }
-        console.log('');
-    }
-    catch (err) {
-        console.error('Failed to list workflow instances:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-const instanceCommand = new Command('instance')
-    .description('Get details for a specific workflow instance')
-    .argument('<id>', 'Workflow instance ID')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--app <name>', 'App name or ID (optional)')
-    .action(async (id, opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const credentials = requireAuth();
-    const client = new ApiClient(credentials);
-    const { workspaceId } = await resolveWorkspace(client, opts);
-    let appId;
-    if (opts.app) {
-        const resolved = await resolveApp(client, workspaceId, opts);
-        appId = resolved.appId;
-    }
-    try {
-        const data = await client.getWorkflowInstance(workspaceId, id, appId);
-        if (useJson) {
-            jsonOut({ instance: data.instance });
-            return;
-        }
-        console.log(JSON.stringify(data.instance, null, 2));
-    }
-    catch (err) {
-        console.error('Failed to get workflow instance:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-export const workflowsCommand = new Command('workflows')
-    .description('Manage workspace workflows')
-    .addCommand(listCommand)
-    .addCommand(triggerCommand)
-    .addCommand(instancesCommand)
-    .addCommand(instanceCommand);

package/dist/deploy/__tests__/deploy-state.test.d.ts

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

package/dist/deploy/__tests__/deploy-state.test.js

@@ -1,80 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('child_process');
-vi.mock('fs', () => ({
-    existsSync: vi.fn(),
-    mkdirSync: vi.fn(),
-    readFileSync: vi.fn(),
-    writeFileSync: vi.fn(),
-}));
-const mockExecFileSync = (await import('child_process')).execFileSync;
-const fs = await import('fs');
-const { summarizeDeploy, getHeadSha, writeDeployState, readDeployState, } = await import('../deploy-state.js');
-const SHA = 'a1b2c3d4e5f600000000000000000000deadbeef';
-describe('deploy/deploy-state', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('summarizeDeploy()', () => {
-        it('reports in-sync when local HEAD matches the deployed SHA', () => {
-            const s = summarizeDeploy(SHA, { sha: SHA, deployedAt: '2026-06-05T00:00:00Z', url: 'https://app' });
-            expect(s.inSync).toBe(true);
-            expect(s.deployedShortSha).toBe('a1b2c3d');
-            expect(s.localShortSha).toBe('a1b2c3d');
-            expect(s.deployedAt).toBe('2026-06-05T00:00:00Z');
-            expect(s.url).toBe('https://app');
-        });
-        it('reports out-of-sync when local HEAD has moved past the deploy', () => {
-            const s = summarizeDeploy('ffffffffffffffffffffffffffffffffffffffff', {
-                sha: SHA, deployedAt: '2026-06-05T00:00:00Z', url: 'https://app',
-            });
-            expect(s.inSync).toBe(false);
-            expect(s.deployedShortSha).toBe('a1b2c3d');
-            expect(s.localShortSha).toBe('fffffff');
-        });
-        it('returns inSync=null when there is no recorded deploy', () => {
-            const s = summarizeDeploy(SHA, null);
-            expect(s.inSync).toBeNull();
-            expect(s.deployedSha).toBeNull();
-            expect(s.localShortSha).toBe('a1b2c3d');
-        });
-        it('returns inSync=null when local HEAD is unknown (not a repo)', () => {
-            const s = summarizeDeploy(null, { sha: SHA, deployedAt: 't', url: '' });
-            expect(s.inSync).toBeNull();
-            expect(s.localSha).toBeNull();
-        });
-    });
-    describe('getHeadSha()', () => {
-        it('returns the trimmed HEAD sha', () => {
-            mockExecFileSync.mockReturnValue(Buffer.from(SHA + '\n'));
-            expect(getHeadSha('/repo')).toBe(SHA);
-        });
-        it('returns null when git fails (no commits / not a repo)', () => {
-            mockExecFileSync.mockImplementation(() => { throw new Error('no HEAD'); });
-            expect(getHeadSha('/repo')).toBeNull();
-        });
-    });
-    describe('writeDeployState() / readDeployState()', () => {
-        it('writes JSON, creating .runwork when missing', () => {
-            vi.mocked(fs.existsSync).mockReturnValue(false);
-            writeDeployState('/repo', { sha: SHA, deployedAt: 't', url: 'https://app' });
-            expect(fs.mkdirSync).toHaveBeenCalled();
-            expect(fs.writeFileSync).toHaveBeenCalledOnce();
-            const written = vi.mocked(fs.writeFileSync).mock.calls[0][1];
-            expect(JSON.parse(written)).toEqual({ sha: SHA, deployedAt: 't', url: 'https://app' });
-        });
-        it('reads back a valid state', () => {
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ sha: SHA, deployedAt: 't', url: 'https://app' }));
-            expect(readDeployState('/repo')).toEqual({ sha: SHA, deployedAt: 't', url: 'https://app' });
-        });
-        it('returns null when the file is missing', () => {
-            vi.mocked(fs.existsSync).mockReturnValue(false);
-            expect(readDeployState('/repo')).toBeNull();
-        });
-        it('returns null when the file is malformed', () => {
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            vi.mocked(fs.readFileSync).mockReturnValue('{ not json');
-            expect(readDeployState('/repo')).toBeNull();
-        });
-    });
-});

package/dist/deploy/__tests__/deploy-status.test.d.ts

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

package/dist/deploy/__tests__/deploy-status.test.js

@@ -1,41 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('fs', () => ({
-    existsSync: vi.fn(),
-    mkdirSync: vi.fn(),
-    readFileSync: vi.fn(),
-    writeFileSync: vi.fn(),
-}));
-const fs = await import('fs');
-const { writeDeployStatus, readDeployStatus, deployLogPath } = await import('../deploy-status.js');
-describe('deploy/deploy-status', () => {
-    beforeEach(() => vi.clearAllMocks());
-    it('writes status JSON, creating .runwork when missing', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(false);
-        writeDeployStatus('/repo', { state: 'in-progress', startedAt: '2026-06-05T00:00:00Z', pid: 123 });
-        expect(fs.mkdirSync).toHaveBeenCalled();
-        const written = vi.mocked(fs.writeFileSync).mock.calls[0][1];
-        expect(JSON.parse(written)).toEqual({ state: 'in-progress', startedAt: '2026-06-05T00:00:00Z', pid: 123 });
-    });
-    it('reads back a valid status', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ state: 'succeeded', startedAt: 't', finishedAt: 'u', url: 'https://app', sha: 'abc' }));
-        expect(readDeployStatus('/repo')).toMatchObject({ state: 'succeeded', url: 'https://app', sha: 'abc' });
-    });
-    it('returns null when the file is missing', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(false);
-        expect(readDeployStatus('/repo')).toBeNull();
-    });
-    it('rejects a malformed state', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ state: 'weird', startedAt: 't' }));
-        expect(readDeployStatus('/repo')).toBeNull();
-    });
-    it('rejects invalid JSON', () => {
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        vi.mocked(fs.readFileSync).mockReturnValue('{ not json');
-        expect(readDeployStatus('/repo')).toBeNull();
-    });
-    it('deployLogPath points at .runwork/deploy-stdout.log', () => {
-        expect(deployLogPath('/repo')).toContain('deploy-stdout.log');
-    });
-});

package/dist/deploy/__tests__/detach-args.test.d.ts

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

package/dist/deploy/__tests__/detach-args.test.js

@@ -1,30 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildDeployChildArgs, isInternalDeployChild, DEPLOY_DETACHED_CHILD_FLAG, } from '../detach.js';
-describe('deploy/detach arg handling', () => {
-    describe('buildDeployChildArgs()', () => {
-        it('drops --detach and appends exactly one child marker', () => {
-            const out = buildDeployChildArgs(['node', '/p/runwork', 'deploy', '--detach']);
-            expect(out).toEqual(['/p/runwork', 'deploy', DEPLOY_DETACHED_CHILD_FLAG]);
-        });
-        it('preserves other flags like --json', () => {
-            const out = buildDeployChildArgs(['node', '/p/runwork', 'deploy', '--detach', '--json']);
-            expect(out).toEqual(['/p/runwork', 'deploy', '--json', DEPLOY_DETACHED_CHILD_FLAG]);
-        });
-        it('does not duplicate the marker when already present', () => {
-            const out = buildDeployChildArgs(['node', '/p/runwork', 'deploy', DEPLOY_DETACHED_CHILD_FLAG]);
-            expect(out.filter(a => a === DEPLOY_DETACHED_CHILD_FLAG)).toHaveLength(1);
-        });
-        it('skips a Bun-on-Windows virtual-FS argv[1]', () => {
-            const out = buildDeployChildArgs(['runwork.exe', 'B:/~BUN/root/runwork-windows-x64.exe', 'deploy', '--detach']);
-            expect(out).toEqual(['deploy', DEPLOY_DETACHED_CHILD_FLAG]);
-        });
-    });
-    describe('isInternalDeployChild()', () => {
-        it('detects the marker', () => {
-            expect(isInternalDeployChild(['node', 'runwork', 'deploy', DEPLOY_DETACHED_CHILD_FLAG])).toBe(true);
-        });
-        it('is false without the marker', () => {
-            expect(isInternalDeployChild(['node', 'runwork', 'deploy'])).toBe(false);
-        });
-    });
-});

package/dist/deploy/deploy-state.d.ts

@@ -1,36 +0,0 @@
-/**
- * Record of the last deploy triggered from this machine, persisted to
- * `.runwork/last-deploy.json`. `sha` is the commit that was pushed and
- * deployed (local HEAD at deploy time), so comparing it to the current HEAD
- * cheaply answers "is what I have locally what's deployed?" without scraping
- * the production bundle (friction log #8).
- *
- * NOTE: this reflects deploys from THIS machine. A teammate deploying
- * elsewhere won't update this file -- an authoritative production-build SHA
- * would require the deploy API to return it (tracked as a follow-up).
- */
-export interface DeployState {
-    sha: string;
-    deployedAt: string;
-    url: string;
-}
-export interface DeploySummary {
-    deployedSha: string | null;
-    deployedShortSha: string | null;
-    deployedAt: string | null;
-    url: string | null;
-    localSha: string | null;
-    localShortSha: string | null;
-    /** true/false when both SHAs are known; null when undeterminable. */
-    inSync: boolean | null;
-}
-/** Current git HEAD commit SHA, or null if not a repo / no commits. */
-export declare function getHeadSha(cwd: string): string | null;
-/** Persist the deploy state for `cwd`. Creates `.runwork/` if needed. */
-export declare function writeDeployState(cwd: string, state: DeployState): void;
-/** Read the recorded deploy state for `cwd`, or null if none/unreadable. */
-export declare function readDeployState(cwd: string): DeployState | null;
-/** Compare the local HEAD against a recorded deploy. Pure (no IO). */
-export declare function summarizeDeploy(localSha: string | null, state: DeployState | null): DeploySummary;
-/** Convenience: read git HEAD + recorded deploy and summarize the comparison. */
-export declare function getDeploySummary(cwd: string): DeploySummary;

package/dist/deploy/deploy-state.js

@@ -1,63 +0,0 @@
-import { execFileSync } from '../utils/subprocess.js';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join } from 'path';
-function deployStatePath(cwd) {
-    return join(cwd, '.runwork', 'last-deploy.json');
-}
-/** Current git HEAD commit SHA, or null if not a repo / no commits. */
-export function getHeadSha(cwd) {
-    try {
-        return execFileSync('git', ['rev-parse', 'HEAD'], { cwd, stdio: ['ignore', 'pipe', 'ignore'] })
-            .toString()
-            .trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Persist the deploy state for `cwd`. Creates `.runwork/` if needed. */
-export function writeDeployState(cwd, state) {
-    const path = deployStatePath(cwd);
-    try {
-        if (!existsSync(dirname(path)))
-            mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, JSON.stringify(state, null, 2));
-    }
-    catch {
-        // Best-effort: a failure to record state must never fail a deploy.
-    }
-}
-/** Read the recorded deploy state for `cwd`, or null if none/unreadable. */
-export function readDeployState(cwd) {
-    const path = deployStatePath(cwd);
-    if (!existsSync(path))
-        return null;
-    try {
-        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
-        if (typeof parsed.sha === 'string' && typeof parsed.deployedAt === 'string') {
-            return { sha: parsed.sha, deployedAt: parsed.deployedAt, url: parsed.url ?? '' };
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Compare the local HEAD against a recorded deploy. Pure (no IO). */
-export function summarizeDeploy(localSha, state) {
-    const deployedSha = state?.sha ?? null;
-    const inSync = deployedSha && localSha ? deployedSha === localSha : null;
-    return {
-        deployedSha,
-        deployedShortSha: deployedSha ? deployedSha.slice(0, 7) : null,
-        deployedAt: state?.deployedAt ?? null,
-        url: state?.url ?? null,
-        localSha,
-        localShortSha: localSha ? localSha.slice(0, 7) : null,
-        inSync,
-    };
-}
-/** Convenience: read git HEAD + recorded deploy and summarize the comparison. */
-export function getDeploySummary(cwd) {
-    return summarizeDeploy(getHeadSha(cwd), readDeployState(cwd));
-}

package/dist/deploy/deploy-status.d.ts

@@ -1,21 +0,0 @@
-/** Lifecycle state of a (possibly detached) deploy run. */
-export type DeployRunState = 'in-progress' | 'succeeded' | 'failed';
-/**
- * Status of the most recent deploy started from this machine, persisted to
- * `.runwork/deploy-status.json`. Lets `runwork deploy --status` report
- * progress/outcome of a `--detach`ed deploy that outlived the shell that
- * launched it (friction log #7).
- */
-export interface DeployStatus {
-    state: DeployRunState;
-    startedAt: string;
-    finishedAt?: string;
-    url?: string;
-    sha?: string;
-    error?: string;
-    pid?: number;
-}
-/** Path of the detached deploy's stdout log (mirrors dev's log convention). */
-export declare function deployLogPath(cwd: string): string;
-export declare function writeDeployStatus(cwd: string, status: DeployStatus): void;
-export declare function readDeployStatus(cwd: string): DeployStatus | null;

package/dist/deploy/deploy-status.js

@@ -1,36 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join } from 'path';
-function statusPath(cwd) {
-    return join(cwd, '.runwork', 'deploy-status.json');
-}
-/** Path of the detached deploy's stdout log (mirrors dev's log convention). */
-export function deployLogPath(cwd) {
-    return join(cwd, '.runwork', 'deploy-stdout.log');
-}
-export function writeDeployStatus(cwd, status) {
-    const path = statusPath(cwd);
-    try {
-        if (!existsSync(dirname(path)))
-            mkdirSync(dirname(path), { recursive: true });
-        writeFileSync(path, JSON.stringify(status, null, 2));
-    }
-    catch {
-        // Best-effort: status recording must never fail a deploy.
-    }
-}
-export function readDeployStatus(cwd) {
-    const path = statusPath(cwd);
-    if (!existsSync(path))
-        return null;
-    try {
-        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
-        if ((parsed.state === 'in-progress' || parsed.state === 'succeeded' || parsed.state === 'failed') &&
-            typeof parsed.startedAt === 'string') {
-            return parsed;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/deploy/detach.d.ts

@@ -1,32 +0,0 @@
-/**
- * `runwork deploy --detach` orchestration.
- *
- * Unlike `runwork dev --detach`, a deploy has no "ready" rendezvous to wait
- * for -- it's fire-and-forget-then-poll. So the parent simply spawns a
- * detached child (whose stdout/stderr go to `.runwork/deploy-*.log`), records
- * an `in-progress` status, prints a poll hint, and exits. The child runs the
- * real deploy and finalizes the status file to `succeeded`/`failed`.
- *
- * This exists so agents whose shell tool times out (~45s) can launch a deploy
- * that survives, then poll `runwork deploy --status` (friction log #7).
- */
-/** Hidden marker passed to the spawned child. Not shown in --help. */
-export declare const DEPLOY_DETACHED_CHILD_FLAG = "--internal-detached-deploy-child";
-/** Whether this invocation is the detached deploy child. */
-export declare function isInternalDeployChild(argv?: readonly string[]): boolean;
-/**
- * Build the args for the spawned child so it re-runs the same deploy in the
- * foreground (the child must NOT re-detach). Drops `--detach`, any stale
- * marker, and a Bun-on-Windows virtual-FS path; re-adds exactly one marker.
- * Pure for testability.
- */
-export declare function buildDeployChildArgs(parentArgv: readonly string[]): string[];
-export interface SpawnedDeployHandle {
-    pid: number;
-}
-/**
- * Spawn the detached deploy child with stdout/stderr routed to
- * `.runwork/deploy-{stdout,stderr}.log`. Cross-platform: uses
- * `process.execPath` so it never depends on PATH (Bun-standalone-safe).
- */
-export declare function spawnDetachedDeploy(childArgs: string[], cwd: string): SpawnedDeployHandle;

package/dist/deploy/detach.js

@@ -1,71 +0,0 @@
-/**
- * `runwork deploy --detach` orchestration.
- *
- * Unlike `runwork dev --detach`, a deploy has no "ready" rendezvous to wait
- * for -- it's fire-and-forget-then-poll. So the parent simply spawns a
- * detached child (whose stdout/stderr go to `.runwork/deploy-*.log`), records
- * an `in-progress` status, prints a poll hint, and exits. The child runs the
- * real deploy and finalizes the status file to `succeeded`/`failed`.
- *
- * This exists so agents whose shell tool times out (~45s) can launch a deploy
- * that survives, then poll `runwork deploy --status` (friction log #7).
- */
-import * as fs from 'fs';
-import * as child_process from 'child_process';
-import { join } from 'path';
-import { looksLikeBunStandaloneArtifact } from '../dev/detach.js';
-/** Hidden marker passed to the spawned child. Not shown in --help. */
-export const DEPLOY_DETACHED_CHILD_FLAG = '--internal-detached-deploy-child';
-/** Whether this invocation is the detached deploy child. */
-export function isInternalDeployChild(argv = process.argv) {
-    return argv.includes(DEPLOY_DETACHED_CHILD_FLAG);
-}
-/**
- * Build the args for the spawned child so it re-runs the same deploy in the
- * foreground (the child must NOT re-detach). Drops `--detach`, any stale
- * marker, and a Bun-on-Windows virtual-FS path; re-adds exactly one marker.
- * Pure for testability.
- */
-export function buildDeployChildArgs(parentArgv) {
-    const rest = [];
-    for (let i = 1; i < parentArgv.length; i++) {
-        if (i === 1 && looksLikeBunStandaloneArtifact(parentArgv[i]))
-            continue;
-        rest.push(parentArgv[i]);
-    }
-    const filtered = rest.filter((a) => a !== DEPLOY_DETACHED_CHILD_FLAG && a !== '--detach');
-    return [...filtered, DEPLOY_DETACHED_CHILD_FLAG];
-}
-/**
- * Spawn the detached deploy child with stdout/stderr routed to
- * `.runwork/deploy-{stdout,stderr}.log`. Cross-platform: uses
- * `process.execPath` so it never depends on PATH (Bun-standalone-safe).
- */
-export function spawnDetachedDeploy(childArgs, cwd) {
-    const dir = join(cwd, '.runwork');
-    fs.mkdirSync(dir, { recursive: true });
-    const stdoutFd = fs.openSync(join(dir, 'deploy-stdout.log'), 'w');
-    const stderrFd = fs.openSync(join(dir, 'deploy-stderr.log'), 'w');
-    try {
-        const proc = child_process.spawn(process.execPath, childArgs, {
-            cwd,
-            env: process.env,
-            detached: true,
-            stdio: ['ignore', stdoutFd, stderrFd],
-            windowsHide: true,
-        });
-        if (proc.pid !== undefined)
-            proc.unref();
-        return { pid: proc.pid ?? 0 };
-    }
-    finally {
-        try {
-            fs.closeSync(stdoutFd);
-        }
-        catch { /* ignore */ }
-        try {
-            fs.closeSync(stderrFd);
-        }
-        catch { /* ignore */ }
-    }
-}

package/dist/dev/__tests__/attach.test.d.ts

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