runwork 0.15.0 → 0.15.2

package/dist/commands/clone.js

@@ -1,271 +0,0 @@
-import { Command } from 'commander';
-import { execFileSync } from '../utils/subprocess.js';
-import { writeFileSync, mkdirSync, existsSync } from 'fs';
-import { join, resolve } from 'path';
-import { requireAuth } from '../auth/store.js';
-import { ApiClient } from '../api/client.js';
-import { promptSelect } from '../utils/prompt.js';
-import { resolveApp } from '../utils/resolve.js';
-import { generateManifest, saveManifest } from '../template/manifest.js';
-import { extractZip } from '../utils/zip.js';
-import { removeNestedGitDirs } from '../utils/fs.js';
-import { runAgentWizard } from '../ui/banner.js';
-import { shouldOutputJson, jsonOut } from '../utils/output.js';
-import { buildCloneGuide, buildErrorResponse } from '../utils/agent-guidance.js';
-import { ensureGitIdentity } from '../git/identity.js';
-import { ensureGitCredentialHelper } from '../git/credentials.js';
-import { ensureRunworkRemote } from '../git/remote.js';
-import { hardenRepoForRestrictedFs } from '../git/repo-config.js';
-import { classifySyncError } from '../git/classify-sync-error.js';
-import { requireGit } from '../git/preflight.js';
-import { formatError } from '../utils/format-error.js';
-export async function execClone(client, app, directory, creds) {
-    const slug = app.slug || app.name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-    const dir = directory || slug;
-    const remoteUrl = client.getGitRemoteUrl(app.workspaceId, app.id);
-    // Step 1: Extract skeleton template as the base layer
-    console.log('Downloading project template...');
-    mkdirSync(dir, { recursive: true });
-    try {
-        const zipData = await client.downloadSkeleton();
-        extractZip(zipData, dir);
-        removeNestedGitDirs(dir);
-    }
-    catch (err) {
-        // Surface the real error so we never silently end up with an empty
-        // clone directory. The clone is best-effort here -- git fetch may
-        // still recover the project below -- but the user should know what
-        // went wrong on the way in.
-        console.warn(`Failed to download template: ${formatError(err)}`);
-        console.warn('Continuing with the git overlay only.');
-    }
-    // Generate template manifest BEFORE git overlay (captures pristine template checksums)
-    const manifest = await generateManifest(dir);
-    await saveManifest(dir, manifest);
-    // Step 2: Git clone into the directory (overlays changed files on top of template)
-    // Init git, add remote, fetch, and checkout to overlay on existing template files
-    if (!existsSync(join(dir, '.git'))) {
-        try {
-            execFileSync('git', ['init'], { cwd: dir, stdio: 'pipe' });
-        }
-        catch (err) {
-            // `stdio: 'pipe'` discards git's stderr, so we have to print the
-            // error ourselves -- otherwise this fails silently and the user
-            // is left with an empty directory and no clue what happened.
-            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.
-        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 */ }
-        // Disable background gc/maintenance so pack rewrites don't fail on
-        // restricted filesystems (e.g. some agent "outputs" mounts). Harmless on
-        // normal filesystems. See git/repo-config.ts.
-        hardenRepoForRestrictedFs(dir);
-    }
-    // Seed a local git identity so subsequent commits do not fail on machines
-    // (commonly fresh Windows installs) without `git config --global user.email`.
-    ensureGitIdentity(dir, creds);
-    // Make sure git can authenticate to the runwork remote before we fetch.
-    // Headless auth paths (the get_cli_setup MCP tool, or a hand-written
-    // ~/.runwork/.credentials) register API creds but not the git helper, so
-    // without this the fetch below silently fails and we fall back to a
-    // template-only scaffold. See git/credentials.ts:ensureGitCredentialHelper.
-    if (creds?.baseUrl) {
-        await ensureGitCredentialHelper(creds.baseUrl);
-    }
-    ensureRunworkRemote(dir, remoteUrl);
-    let source = { pulled: true };
-    try {
-        execFileSync('git', ['fetch', 'runwork', 'main'], { cwd: dir, stdio: 'pipe' });
-        // Reset to remote HEAD - overlays git-tracked files on top of template
-        execFileSync('git', ['reset', '--mixed', 'runwork/main'], { cwd: dir, stdio: 'pipe' });
-        // Checkout git-tracked files (overwrites template files where they differ)
-        execFileSync('git', ['checkout', '.'], { cwd: dir, stdio: 'pipe' });
-    }
-    catch (err) {
-        source = pullOutcomeFromError(err);
-        if (source.reason === 'empty-remote') {
-            // Brand-new app: the remote has no `main` branch yet. Expected and
-            // benign -- the template scaffold IS the starting point.
-            console.warn('No source pushed for this app yet. Starting from the template scaffold.');
-        }
-        else {
-            // A real failure (auth, missing remote, network). The scaffold here is
-            // NOT the app's code -- surface it loudly so the caller fails instead of
-            // silently editing the wrong files.
-            console.warn('Could not pull the app source from the runwork remote.');
-            console.warn(`  ${formatError(err)}`);
-        }
-    }
-    // Write .runwork.json config
-    const config = {
-        workspaceId: app.workspaceId,
-        workspaceName: app.workspaceName,
-        appId: app.id,
-        appName: app.name,
-    };
-    writeFileSync(join(dir, '.runwork.json'), JSON.stringify(config, null, 2));
-    // Fetch SKILL.md (best-effort)
-    try {
-        const { skill } = await client.getAppSkill(app.id);
-        if (skill) {
-            writeFileSync(join(dir, 'SKILL.md'), skill, 'utf-8');
-        }
-    }
-    catch {
-        // App may be new with no registries yet
-    }
-    return {
-        appId: app.id,
-        appName: app.name,
-        slug,
-        directory: resolve(dir),
-        workspaceId: app.workspaceId,
-        workspaceName: app.workspaceName,
-        source,
-    };
-}
-/** Pull the raw git stderr off an execFileSync error for classification. */
-function extractStderr(err) {
-    const e = err;
-    if (e?.stderr)
-        return e.stderr.toString().trim();
-    return formatError(err);
-}
-/**
- * Whether a failed `git fetch runwork main` means the remote simply has no
- * `main` branch yet (a brand-new app), as opposed to an auth/network/remote
- * failure. Git reports this as "couldn't find remote ref main".
- */
-function isEmptyRemote(stderr) {
-    const s = stderr.toLowerCase();
-    return s.includes("couldn't find remote ref") || s.includes('could not find remote ref');
-}
-/**
- * Turn a failed-pull error into a CloneSource: an empty remote (benign,
- * brand-new app) vs a classified real failure (auth/network/no-remote) that
- * leaves a template-only scaffold.
- */
-export function pullOutcomeFromError(err) {
-    const detail = extractStderr(err);
-    if (isEmptyRemote(detail)) {
-        return { pulled: false, reason: 'empty-remote', detail };
-    }
-    return { pulled: false, reason: classifySyncError(detail), detail };
-}
-/**
- * A clone is a real failure -- a template-only scaffold rather than the app's
- * code -- when the source pull didn't happen for any reason other than an
- * empty remote. Callers must not report success in that case.
- */
-export function isCloneSourceFailure(source) {
-    return !source.pulled && source.reason !== 'empty-remote';
-}
-/**
- * Reconcile positional args with --app. When --app is provided, the first
- * positional argument is intended as the *directory* -- not another appId
- * -- because the app is already disambiguated by the option. Without this,
- * `runwork clone --app foo C:\path\to\dir` ends up parsing `C:\path\to\dir`
- * as `appId` (which is then ignored because `--app` wins), leaving
- * `directory` undefined and silently cloning into the slug under cwd.
- */
-export function normalizeCloneArgs(appId, directory, options) {
-    if (options?.app && appId && !directory) {
-        return { appId: undefined, directory: appId };
-    }
-    return { appId, directory };
-}
-/**
- * Help epilogue shown under `runwork clone --help`. Agents tend to read help
- * before running, so we surface the restricted-mount caveat (friction log #9)
- * here. Exported so it can be asserted on directly (commander's help-text
- * hooks aren't reflected by `helpInformation()`).
- */
-export const RESTRICTED_FS_HELP = `
-Note for AI agents: clone into a normal working directory. Some sandboxed
-"outputs" mounts (e.g. certain agent environments) disallow the unlink
-operations git uses for pack files, which can corrupt the repo with errors
-like "unable to unlink '.git/objects/pack/...': Operation not permitted". If
-you hit that, clone into your home directory or another standard path instead.`;
-export const cloneCommand = new Command('clone')
-    .description('Clone a Runwork app to local development')
-    .argument('[appId]', 'App ID to clone (interactive if omitted)')
-    .argument('[directory]', 'Target directory')
-    .option('--app <name-or-id>', 'App name or ID (skips interactive selection)')
-    .addHelpText('after', RESTRICTED_FS_HELP)
-    .action(async (rawAppId, rawDirectory, options) => {
-    requireGit('clone');
-    const { appId, directory } = normalizeCloneArgs(rawAppId, rawDirectory, options);
-    const creds = requireAuth();
-    const client = new ApiClient(creds);
-    const useJson = shouldOutputJson(undefined);
-    let app;
-    const appRef = options?.app || appId;
-    if (appRef) {
-        app = await resolveApp(client, appRef);
-    }
-    else {
-        const apps = await client.listApps();
-        if (apps.length === 0) {
-            if (useJson) {
-                jsonOut(buildErrorResponse('clone', 'No apps found', 'No apps are available to clone.', ['Create an app first with: runwork init my-app']));
-                return;
-            }
-            console.error('No apps found.');
-            process.exit(1);
-        }
-        const choice = await promptSelect('Select app to clone:', apps.map(a => ({ label: `${a.name} (${a.workspaceName})`, value: a })));
-        app = choice.value;
-    }
-    if (!useJson) {
-        console.log(`Cloning "${app.name}"...`);
-    }
-    const cloneResult = await execClone(client, app, directory, creds);
-    // A real pull failure (auth/network/missing-remote) left a template-only
-    // scaffold that is NOT the app's deployed code. Report it as a failure so
-    // an agent doesn't start editing the wrong files (friction log #1).
-    const pullFailed = isCloneSourceFailure(cloneResult.source);
-    if (useJson) {
-        if (pullFailed) {
-            jsonOut(buildErrorResponse('clone', 'Cloned the scaffold but could not pull the app source', `git could not fetch the app's source (${cloneResult.source.reason}), so the directory holds only the template scaffold, not the deployed code. ${cloneResult.source.detail ?? ''}`.trim(), [
-                'Run `runwork doctor --fix` to repair git auth and the runwork remote',
-                `Then re-clone: runwork clone --app ${cloneResult.appName}`,
-            ]));
-            process.exit(1);
-        }
-        const response = {
-            success: true,
-            command: 'clone',
-            result: cloneResult,
-            warning: cloneResult.source.reason === 'empty-remote'
-                ? 'This app has no source pushed yet. The directory is the starting template scaffold.'
-                : undefined,
-            guide: buildCloneGuide(cloneResult.appName, cloneResult.slug),
-        };
-        jsonOut(response);
-        return;
-    }
-    if (pullFailed) {
-        console.error(`\nCloned the scaffold for "${cloneResult.appName}", but could NOT pull the app source (${cloneResult.source.reason}).`);
-        console.error('The directory holds only the template scaffold, not the deployed code.');
-        console.error('Fix git access, then re-clone:');
-        console.error('  runwork doctor --fix');
-        console.error(`  runwork clone --app ${cloneResult.appName}`);
-        process.exit(1);
-    }
-    // No trailing separator: cloneResult.directory is already an absolute
-    // path. Appending '/' here mixed with Windows '\' separators produced
-    // confusing output like `C:\Users\...\app/` on Windows.
-    console.log(`\nApp "${cloneResult.appName}" cloned to ${cloneResult.directory}`);
-    if (cloneResult.source.reason === 'empty-remote') {
-        console.log('Note: no source pushed for this app yet. Starting from the template scaffold.');
-    }
-    console.log(`Remote: ${client.getGitRemoteUrl(cloneResult.workspaceId, cloneResult.appId)}`);
-    await runAgentWizard(cloneResult.directory);
-    console.log(`Next: cd ${cloneResult.slug} && runwork dev`);
-});

package/dist/commands/components.d.ts

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

package/dist/commands/components.js

@@ -1,43 +0,0 @@
-import { Command } from 'commander';
-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';
-const listCommand = new Command('list')
-    .description('List components registered in the workspace')
-    .option('--workspace <id>', 'Workspace ID')
-    .option('--app <id>', '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 components = await client.listComponents(workspaceId);
-        if (opts.app) {
-            components = components.filter(c => c.appId === opts.app || c.appName === opts.app);
-        }
-        if (useJson) {
-            jsonOut({ components });
-            return;
-        }
-        if (components.length === 0) {
-            console.log('No components found in this workspace.');
-            return;
-        }
-        console.log(`\nWorkspace: ${workspaceName || workspaceId}\n`);
-        console.log(`  ${'Component'.padEnd(28)} ${'App'.padEnd(24)} ${'Mode'.padEnd(12)}`);
-        console.log('  ' + '-'.repeat(66));
-        for (const c of components) {
-            console.log(`  ${c.componentName.padEnd(28)} ${c.appName.padEnd(24)} ${(c.deploymentMode ?? '').padEnd(12)}`);
-        }
-        console.log('');
-    }
-    catch (err) {
-        console.error('Failed to list components:', err instanceof Error ? err.message : err);
-        process.exit(1);
-    }
-});
-export const componentsCommand = new Command('components')
-    .description('List workspace components')
-    .addCommand(listCommand);

package/dist/commands/deploy.d.ts

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

package/dist/commands/deploy.js

@@ -1,279 +0,0 @@
-import { Command, Option } from 'commander';
-import { readFileSync, existsSync } from 'fs';
-import { requireAuth } from '../auth/store.js';
-import { ApiClient } from '../api/client.js';
-import { shouldOutputJson, jsonOut, jsonLine } from '../utils/output.js';
-import { dim, green, yellow } from '../ui/colors.js';
-import { getHeadSha, writeDeployState, getDeploySummary } from '../deploy/deploy-state.js';
-import { writeDeployStatus, readDeployStatus, deployLogPath } from '../deploy/deploy-status.js';
-import { isInternalDeployChild, buildDeployChildArgs, spawnDetachedDeploy, DEPLOY_DETACHED_CHILD_FLAG } from '../deploy/detach.js';
-import { buildDeployGuide, buildErrorResponse } from '../utils/agent-guidance.js';
-import { requireGit } from '../git/preflight.js';
-import { ensureGitIdentity } from '../git/identity.js';
-import { ensureGitCredentialHelper } from '../git/credentials.js';
-import { ensureRunworkRemote } from '../git/remote.js';
-import { diagnoseSyncError } from '../git/classify-sync-error.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')
-    .option('-y, --yes', 'Skip the confirmation prompt when the working tree differs from the preview')
-    .option('--detach', 'Run the deploy in the background and return immediately. Logs go to .runwork/deploy-{stdout,stderr}.log; poll `runwork deploy --status`.')
-    .option('--status', 'Show the status (in-progress/succeeded/failed) of the last deploy started from this machine, plus the deployed-vs-local commit.')
-    // Hidden marker the `--detach` parent passes to its background child. Not
-    // for end users -- registered so commander accepts it on the child.
-    .addOption(new Option(DEPLOY_DETACHED_CHILD_FLAG).hideHelp())
-    .action(async (opts, command) => {
-    const useJson = shouldOutputJson(command.optsWithGlobals().json);
-    const cwd = process.cwd();
-    if (!existsSync('.runwork.json')) {
-        if (useJson) {
-            jsonOut(buildErrorResponse('deploy', 'No .runwork.json found', 'This directory is not a Runwork app.', ['Run runwork init to create an app first', 'Or cd into an existing app directory']));
-            process.exit(1);
-        }
-        console.error('No .runwork.json found. Run `runwork init` first.');
-        process.exit(1);
-    }
-    // --status: a local read; no auth/git required.
-    if (opts.status) {
-        printDeployStatus(cwd, useJson);
-        return;
-    }
-    requireGit('deploy');
-    const config = JSON.parse(readFileSync('.runwork.json', 'utf-8'));
-    const isChild = isInternalDeployChild(process.argv);
-    // --detach parent: spawn a background child running the real deploy,
-    // record an in-progress status, print a poll hint, and exit immediately so
-    // the launching shell doesn't time out (friction log #7).
-    if (opts.detach && !isChild) {
-        const startedAt = new Date().toISOString();
-        const handle = spawnDetachedDeploy(buildDeployChildArgs(process.argv), cwd);
-        writeDeployStatus(cwd, { state: 'in-progress', startedAt, pid: handle.pid });
-        if (useJson) {
-            jsonLine({ event: 'deploy_started', detached: true, pid: handle.pid, logPath: deployLogPath(cwd), startedAt, hint: 'Poll `runwork deploy --status` for completion.' });
-        }
-        else {
-            console.log(`Deploy started in the background (pid ${handle.pid}).`);
-            console.log(`Logs:  ${deployLogPath(cwd)}`);
-            console.log('Check: runwork deploy --status');
-        }
-        return;
-    }
-    // The detached child finalizes the status file on exit. If it crashes or
-    // hits any `process.exit(1)` failure path before the success block marks
-    // it done, record `failed` so `--status` doesn't report a stuck deploy.
-    // Register this BEFORE requireAuth(): a child whose credentials expired
-    // between spawn and run would otherwise exit in requireAuth() with the
-    // status stuck at `in-progress`. (requireGit/config above ran identically
-    // in the parent before it spawned this child, so they can't fail here.)
-    let deployFinalized = false;
-    const childStartedAt = readDeployStatus(cwd)?.startedAt ?? new Date().toISOString();
-    if (isChild) {
-        jsonLine({ event: 'deploy_started', startedAt: childStartedAt });
-        process.on('exit', (code) => {
-            if (!deployFinalized && code !== 0) {
-                writeDeployStatus(cwd, { state: 'failed', startedAt: childStartedAt, finishedAt: new Date().toISOString(), error: `deploy process exited with code ${code}` });
-            }
-        });
-    }
-    const creds = requireAuth();
-    const client = new ApiClient(creds);
-    // 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 || isChild || !process.stdin.isTTY) {
-            // Non-interactive (no TTY), the detached child, or explicit --yes:
-            // warn and proceed without prompting.
-            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);
-    // Ensure git can authenticate to the runwork remote before sync/push.
-    // Headless auth (get_cli_setup / hand-written credentials) registers API
-    // creds but not the git helper. See
-    // git/credentials.ts:ensureGitCredentialHelper.
-    if (creds?.baseUrl) {
-        await ensureGitCredentialHelper(creds.baseUrl);
-    }
-    // Ensure the `runwork` remote exists and points at the canonical URL, so a
-    // manually `git clone`d repo (remote named `origin`) still syncs/pushes.
-    ensureRunworkRemote(cwd, client.getGitRemoteUrl(config.workspaceId, config.appId));
-    if (!useJson)
-        console.log('Syncing...');
-    try {
-        commitWorkingTree(cwd, `deploy: ${new Date().toISOString().replace('T', ' ').slice(0, 19)}`);
-    }
-    catch {
-        // 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);
-    }
-    // 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.');
-        }
-    }
-    if (syncResult.status === 'sync-failed') {
-        const diag = diagnoseSyncError(syncResult.error);
-        if (useJson) {
-            jsonOut(buildErrorResponse('deploy', 'Sync failed before deployment', diag.diagnosis, [...diag.suggestions, 'Then retry runwork deploy']));
-            process.exit(1);
-        }
-        console.error(`Sync failed: ${diag.message}. ${diag.diagnosis}`);
-        for (const s of diag.suggestions)
-            console.error(`  - ${s}`);
-        process.exit(1);
-    }
-    if (!syncResult.pushed) {
-        if (useJson) {
-            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('Push failed. Check your connection and retry `runwork deploy`.');
-        process.exit(1);
-    }
-    // Trigger deploy
-    if (!useJson)
-        console.log('Deploying...');
-    let result;
-    try {
-        result = await client.triggerDeploy(config.appId);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        if (useJson) {
-            jsonOut(buildErrorResponse('deploy', message, 'The deployment API returned an error.', ['Check for TypeScript errors in your code', 'Run runwork dev to test in the sandbox first', 'Retry runwork deploy']));
-            process.exit(1);
-        }
-        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);
-    }
-    // Record what we just deployed (local HEAD == the pushed/deployed commit)
-    // so `runwork info` / `deploy --status` can cheaply compare it to HEAD
-    // later without scraping the production bundle.
-    const deployedSha = getHeadSha(cwd);
-    const finishedAt = new Date().toISOString();
-    if (deployedSha) {
-        writeDeployState(cwd, { sha: deployedSha, deployedAt: finishedAt, url: deploymentUrl });
-    }
-    // Mark the deploy finished so the child's exit hook doesn't overwrite this
-    // with a `failed` status, and so `runwork deploy --status` reports success.
-    deployFinalized = true;
-    writeDeployStatus(cwd, { state: 'succeeded', startedAt: childStartedAt, finishedAt, url: deploymentUrl, sha: deployedSha ?? undefined });
-    if (isChild) {
-        jsonLine({ event: 'deploy_succeeded', url: deploymentUrl, deployedSha, finishedAt });
-    }
-    if (useJson) {
-        const response = {
-            success: true,
-            command: 'deploy',
-            result: {
-                deployed,
-                url: deploymentUrl,
-                appName: config.appName,
-                deployedSha,
-            },
-            guide: buildDeployGuide(),
-            ...(deployGuardWarning ? { warning: deployGuardWarning } : {}),
-        };
-        jsonOut(response);
-        return;
-    }
-    console.log(`Deployed: ${deploymentUrl}`);
-    if (deployedSha)
-        console.log(dim(`Commit: ${deployedSha.slice(0, 7)}`));
-});
-/**
- * Print the status of the last deploy started from this machine
- * (`runwork deploy --status`), reconciled with the deployed-vs-local commit
- * comparison from deploy-state.
- */
-function printDeployStatus(cwd, useJson) {
-    const status = readDeployStatus(cwd);
-    const summary = getDeploySummary(cwd);
-    if (useJson) {
-        jsonOut({ success: true, command: 'deploy', result: { status, deploy: summary } });
-        return;
-    }
-    if (!status) {
-        console.log('No deploy has been started from this machine yet.');
-    }
-    else {
-        const label = status.state === 'succeeded' ? green('succeeded')
-            : status.state === 'failed' ? yellow('failed')
-                : 'in-progress';
-        console.log(`Last deploy: ${label}`);
-        console.log(dim(`  started:  ${status.startedAt}`));
-        if (status.finishedAt)
-            console.log(dim(`  finished: ${status.finishedAt}`));
-        if (status.url)
-            console.log(dim(`  url:      ${status.url}`));
-        if (status.error)
-            console.log(yellow(`  error:    ${status.error}`));
-        if (status.state === 'in-progress')
-            console.log(dim(`  logs:     ${deployLogPath(cwd)}`));
-    }
-    if (summary.deployedShortSha) {
-        const sync = summary.inSync === true ? green('in sync')
-            : summary.inSync === false ? yellow('local has undeployed commits')
-                : dim('unknown');
-        console.log(`Commit: deployed ${summary.deployedShortSha}${summary.localShortSha ? `, local ${summary.localShortSha}` : ''} ${sync}`);
-    }
-}

package/dist/commands/dev.d.ts

@@ -1,11 +0,0 @@
-import { Command } from 'commander';
-import { type SessionMode } from '../dev/session.js';
-export declare function execDev(options?: {
-    logs?: boolean;
-    logsOnlyFile?: boolean;
-    json?: boolean;
-    mode?: SessionMode;
-    restart?: boolean;
-    noSync?: boolean;
-}): Promise<void>;
-export declare const devCommand: Command;