runwork 0.10.3 → 0.10.4

package/dist/agents/__tests__/claude-code-stats.test.js

@@ -199,6 +199,7 @@ describe('ClaudeCodeAdapter.readVersion', () => {
         expect(version).toBe('claude-code 1.0.23');
         expect(execFileSync).toHaveBeenCalledWith('claude', ['--version'], {
             stdio: 'pipe',
+            windowsHide: true,
         });
     });
     it('returns null when claude is not installed', async () => {

package/dist/agents/claude-code.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir, platform } from 'os';
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { whichBinary } from '../utils/which.js';
 import { buildSkillMd } from './types.js';
 import { mergeJsonMcpServers, readJsonConfig, writeJsonConfig, removeRunworkMcpServers } from './utils/json-config.js';

package/dist/agents/cursor.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir, platform } from 'os';
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { querySqlite, openWritableSqlite } from '../utils/sqlite.js';
 import { whichBinary } from '../utils/which.js';
 import { mergeJsonMcpServers, removeRunworkMcpServers, readJsonConfig, writeJsonConfig } from './utils/json-config.js';

package/dist/commands/clone.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join, resolve } from 'path';
 import { requireAuth } from '../auth/store.js';

package/dist/commands/deploy.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { readFileSync, existsSync } from 'fs';
 import { requireAuth } from '../auth/store.js';
 import { ApiClient } from '../api/client.js';

package/dist/commands/dev.js

@@ -1,5 +1,5 @@
 import { Command, Option } from 'commander';
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import { requireAuth } from '../auth/store.js';
@@ -11,7 +11,7 @@ import { requireGit } from '../git/preflight.js';
 import { startLogTailer } from '../logs/tailer.js';
 import { startPreviewUrlPoller } from '../dev/preview-url-poller.js';
 import { buildSessionFile, getSessionState, readSessionFile, removeSessionFile, removeSessionFileIfOwned, writeSessionFile, } from '../dev/session.js';
-import { INTERNAL_DETACHED_CHILD_FLAG, isInternalDetachedChild, runAsDetachedParent, stripInternalChildFlag, } from '../dev/detach.js';
+import { INTERNAL_DETACHED_CHILD_FLAG, buildChildArgs, isInternalDetachedChild, runAsDetachedParent, } from '../dev/detach.js';
 import { stopSession } from '../dev/stop.js';
 import { formatStartedAgo, getAttachLogPaths, getCurrentPreviewUrl, renderLogLine, resolveAttachTarget, startLogTail, startSessionFileWatch, } from '../dev/attach.js';
 import { populateTypes } from '../types-manager.js';
@@ -164,19 +164,31 @@ export async function execDev(options) {
     // fresh machine where `git config --global user.email/.name` has never
     // been set (extremely common on Windows after a clean install).
     ensureGitIdentity(cwd, creds);
-    // Detect user edits made outside of `runwork dev`
+    // Detect user edits made outside of `runwork dev`. When this fires
+    // for an AI agent, it almost always means the agent edited code
+    // before starting dev -- the wrong order. We surface this loudly so
+    // the agent's tool-result-handling can correct course on the next
+    // task. The recommendation is canonical: start `runwork dev --detach`
+    // first, then edit. See DEV_FIRST_RULE.
     const oldManifest = await loadManifest(cwd);
     if (oldManifest) {
         const userEdits = await detectUserEdits(cwd, oldManifest);
         if (userEdits.length > 0) {
             if (useJson) {
-                jsonLine({ event: 'startup', phase: 'user_edits_detected', files: userEdits, timestamp: ts() });
+                jsonLine({
+                    event: 'startup',
+                    phase: 'user_edits_detected',
+                    files: userEdits,
+                    timestamp: ts(),
+                    warning: `Detected ${userEdits.length} file(s) edited before \`runwork dev\` was running. These will be batch-synced now. Next time, start \`runwork dev --detach\` BEFORE editing so changes flow incrementally and you can verify each edit against the preview.`,
+                });
             }
             else {
                 console.log(`Detected ${userEdits.length} file(s) edited outside dev session:`);
                 for (const file of userEdits) {
                     console.log(`  ${file}`);
                 }
+                console.log(yellow(`  Next time, start \`runwork dev --detach\` BEFORE editing -- changes will sync incrementally and the preview will validate each one.`));
             }
             try {
                 execFileSync('git', ['add', '--', ...userEdits], { stdio: 'pipe' });
@@ -552,20 +564,12 @@ async function runDevDetachParent(opts) {
     else {
         console.log(dim('Starting dev session in background...'));
     }
-    // Construct the child's args from our own process.argv. We strip the
-    // marker (so the parent can't accidentally fall into the child path
-    // itself if invoked through a wrapper) and then add it back exactly
-    // once.
-    //
-    // process.argv[0] is the executable, which we replace with
-    // `process.execPath` at spawn time. We forward everything from argv[1]
-    // onwards. This works for both Node (`node script.js dev --detach` ->
-    // ["script.js", "dev", "--detach"]) and Bun-standalone binaries
-    // (`runwork dev --detach` -> ["dev", "--detach"]) because in both cases
-    // re-spawning with execPath + argv.slice(1) reproduces the same
-    // invocation.
-    const userArgs = stripInternalChildFlag(process.argv.slice(1));
-    const childArgs = [...userArgs, INTERNAL_DETACHED_CHILD_FLAG];
+    // `buildChildArgs` reproduces our invocation as args for the child
+    // (which is spawned with the same `process.execPath`), with two
+    // platform-aware tweaks: it skips Bun's auto-injected virtual-FS path
+    // on Windows (which the child runtime re-injects on its own), and it
+    // ensures exactly one copy of the internal-child marker.
+    const childArgs = buildChildArgs(process.argv);
     const outcome = await runAsDetachedParent({
         appDir: cwd,
         expectedAppId: config.appId,

package/dist/commands/init.js

@@ -1,5 +1,5 @@
 import { Command } from 'commander';
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { writeFileSync, existsSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
 import { homedir } from 'os';

package/dist/dev/__tests__/detach.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { pollForSession, runAsDetachedParent, isInternalDetachedChild, stripInternalChildFlag, INTERNAL_DETACHED_CHILD_FLAG, } from '../detach.js';
+import { buildChildArgs, pollForSession, runAsDetachedParent, isInternalDetachedChild, looksLikeBunStandaloneArtifact, stripInternalChildFlag, INTERNAL_DETACHED_CHILD_FLAG, } from '../detach.js';
 import { buildSessionFile, getSessionPaths, writeSessionFile, } from '../session.js';
 function createTmpAppDir() {
     return fs.mkdtempSync(path.join(os.tmpdir(), 'runwork-detach-test-'));
@@ -32,6 +32,82 @@ describe('isInternalDetachedChild() / stripInternalChildFlag()', () => {
         expect(stripInternalChildFlag(['dev', '--detach'])).toEqual(['dev', '--detach']);
     });
 });
+describe('looksLikeBunStandaloneArtifact()', () => {
+    it('detects Bun-on-Windows virtual-FS paths (forward slashes)', () => {
+        expect(looksLikeBunStandaloneArtifact('B:/~BUN/root/runwork-windows-x64.exe')).toBe(true);
+        expect(looksLikeBunStandaloneArtifact('C:/~BUN/root/foo.exe')).toBe(true);
+    });
+    it('detects Bun-on-Windows virtual-FS paths (backslashes)', () => {
+        expect(looksLikeBunStandaloneArtifact('B:\\~BUN\\root\\runwork.exe')).toBe(true);
+    });
+    it('detects bunfs prefix on POSIX (defensive)', () => {
+        expect(looksLikeBunStandaloneArtifact('/$bunfs/root/runwork')).toBe(true);
+    });
+    it('does not flag normal paths or arguments', () => {
+        expect(looksLikeBunStandaloneArtifact('dev')).toBe(false);
+        expect(looksLikeBunStandaloneArtifact('--detach')).toBe(false);
+        expect(looksLikeBunStandaloneArtifact('/usr/local/bin/runwork')).toBe(false);
+        expect(looksLikeBunStandaloneArtifact('C:/Users/Oytun/.runwork/bin/runwork.exe')).toBe(false);
+        expect(looksLikeBunStandaloneArtifact('node')).toBe(false);
+    });
+});
+describe('buildChildArgs()', () => {
+    it('Node script invocation: forwards script path + user args, appends marker', () => {
+        // node /path/to/dist/index.js dev --detach
+        const argv = ['node', '/path/to/dist/index.js', 'dev', '--detach'];
+        expect(buildChildArgs(argv)).toEqual([
+            '/path/to/dist/index.js', 'dev', '--detach', INTERNAL_DETACHED_CHILD_FLAG,
+        ]);
+    });
+    it('Bun standalone macOS/Linux: forwards user args directly', () => {
+        // /usr/local/bin/runwork dev --detach
+        const argv = ['/usr/local/bin/runwork', 'dev', '--detach'];
+        expect(buildChildArgs(argv)).toEqual([
+            'dev', '--detach', INTERNAL_DETACHED_CHILD_FLAG,
+        ]);
+    });
+    it('Bun standalone Windows: drops the virtual-FS argv[1] before forwarding', () => {
+        // The exact failure from the field. Bun-on-Windows injects argv[1]
+        // = "B:/~BUN/root/runwork-windows-x64.exe". We must NOT forward it
+        // -- the child Bun runtime will inject its own.
+        const argv = [
+            'C:\\Users\\Oytun\\.runwork\\bin\\runwork.exe',
+            'B:/~BUN/root/runwork-windows-x64.exe',
+            'dev',
+            '--detach',
+        ];
+        expect(buildChildArgs(argv)).toEqual([
+            'dev', '--detach', INTERNAL_DETACHED_CHILD_FLAG,
+        ]);
+    });
+    it('strips an existing internal-child flag and re-adds exactly one', () => {
+        const argv = [
+            '/usr/local/bin/runwork',
+            'dev',
+            '--detach',
+            INTERNAL_DETACHED_CHILD_FLAG,
+            INTERNAL_DETACHED_CHILD_FLAG,
+        ];
+        const out = buildChildArgs(argv);
+        expect(out.filter((a) => a === INTERNAL_DETACHED_CHILD_FLAG)).toHaveLength(1);
+    });
+    it('preserves the order of user args and only mutates argv[0..1]', () => {
+        const argv = [
+            'C:\\bin\\runwork.exe',
+            'B:/~BUN/root/runwork-windows-x64.exe',
+            'dev',
+            '--restart',
+            '--detach',
+            '--json',
+        ];
+        expect(buildChildArgs(argv)).toEqual([
+            'dev', '--restart', '--detach', '--json', INTERNAL_DETACHED_CHILD_FLAG,
+        ]);
+    });
+    it('handles an empty argv tail (just the binary)', () => {
+        expect(buildChildArgs(['runwork'])).toEqual([INTERNAL_DETACHED_CHILD_FLAG]);
+    });
+});
 describe('pollForSession()', () => {
     let appDir;
     beforeEach(() => {

package/dist/dev/detach.d.ts

@@ -162,3 +162,26 @@ export declare function isInternalDetachedChild(argv?: readonly string[]): boole
  * misconfigured wrapper).
  */
 export declare function stripInternalChildFlag(args: readonly string[]): string[];
+/**
+ * Detect a Bun standalone virtual-filesystem path. Bun's compile mode
+ * on Windows injects the in-bundle script path as `process.argv[1]`
+ * (e.g., `B:/~BUN/root/runwork-windows-x64.exe`). When we self-spawn,
+ * the child Bun runtime re-injects an equivalent entry on its own --
+ * forwarding ours causes a duplicate that downstream parsers (commander
+ * here) misread as a stray positional command. macOS and Linux Bun
+ * standalone do NOT inject this entry, but the prefix is documented in
+ * Bun source as `/$bunfs/` if it ever appears, so we detect that too
+ * defensively.
+ */
+export declare function looksLikeBunStandaloneArtifact(p: string): boolean;
+/**
+ * Construct the args we should forward to the spawned child so it
+ * re-runs the same `runwork dev` invocation as the parent. Drops
+ * elements that the child runtime will re-inject on its own (notably
+ * the Bun-on-Windows virtual-FS path) and drops any pre-existing copy
+ * of the internal-child marker before we re-add exactly one.
+ *
+ * Pure function for testability -- accepts the parent's argv and returns
+ * what to hand to `spawn`. Real callers pass `process.argv`.
+ */
+export declare function buildChildArgs(parentArgv: readonly string[]): string[];

package/dist/dev/detach.js

@@ -245,3 +245,48 @@ export function isInternalDetachedChild(argv = process.argv) {
 export function stripInternalChildFlag(args) {
     return args.filter((a) => a !== INTERNAL_DETACHED_CHILD_FLAG);
 }
+/**
+ * Detect a Bun standalone virtual-filesystem path. Bun's compile mode
+ * on Windows injects the in-bundle script path as `process.argv[1]`
+ * (e.g., `B:/~BUN/root/runwork-windows-x64.exe`). When we self-spawn,
+ * the child Bun runtime re-injects an equivalent entry on its own --
+ * forwarding ours causes a duplicate that downstream parsers (commander
+ * here) misread as a stray positional command. macOS and Linux Bun
+ * standalone do NOT inject this entry, but the prefix is documented in
+ * Bun source as `/$bunfs/` if it ever appears, so we detect that too
+ * defensively.
+ */
+export function looksLikeBunStandaloneArtifact(p) {
+    // Windows: drive-letter paths under \~BUN\, e.g. "B:/~BUN/root/..." or "B:\~BUN\root\..."
+    if (/^[a-z]:[/\\]~BUN[/\\]/i.test(p))
+        return true;
+    // Linux/macOS bunfs prefix (documented; not currently emitted in user-visible argv).
+    if (p.startsWith('/$bunfs/'))
+        return true;
+    return false;
+}
+/**
+ * Construct the args we should forward to the spawned child so it
+ * re-runs the same `runwork dev` invocation as the parent. Drops
+ * elements that the child runtime will re-inject on its own (notably
+ * the Bun-on-Windows virtual-FS path) and drops any pre-existing copy
+ * of the internal-child marker before we re-add exactly one.
+ *
+ * Pure function for testability -- accepts the parent's argv and returns
+ * what to hand to `spawn`. Real callers pass `process.argv`.
+ */
+export function buildChildArgs(parentArgv) {
+    // argv[0] is always the binary; the child gets it back via spawn's
+    // execPath argument. We start scanning from argv[1].
+    const rest = [];
+    for (let i = 1; i < parentArgv.length; i++) {
+        if (i === 1 && looksLikeBunStandaloneArtifact(parentArgv[i])) {
+            // Skip Bun-on-Windows's auto-injected virtual-FS path; the child
+            // runtime injects its own equivalent entry. Forwarding ours would
+            // duplicate it in the child's argv.
+            continue;
+        }
+        rest.push(parentArgv[i]);
+    }
+    return [...stripInternalChildFlag(rest), INTERNAL_DETACHED_CHILD_FLAG];
+}

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.10.3";
+export declare const VERSION = "0.10.4";

package/dist/generated/version.js

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

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

@@ -60,7 +60,7 @@ describe('git/credentials', () => {
                 '--global',
                 '--unset',
                 'credential.https://runwork.ai.helper',
-            ], { stdio: 'pipe' });
+            ], { stdio: 'pipe', windowsHide: true });
         });
         it('ignores errors silently', async () => {
             mockExecFileSync.mockImplementation(() => {

package/dist/git/auto-commit.js

@@ -1,4 +1,4 @@
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { readFileSync } from 'fs';
 import { watch } from 'chokidar';
 import { join, relative } from 'path';

package/dist/git/credentials.js

@@ -1,4 +1,4 @@
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { getCredentials } from '../auth/store.js';
 /**
  * Build the value we hand to `git config credential.<origin>.helper`.

package/dist/git/identity.js

@@ -1,4 +1,4 @@
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 /**
  * Default identity used when we cannot derive anything better from the
  * authenticated credentials. Local-scoped, never written to global config,

package/dist/git/preflight.js

@@ -1,4 +1,4 @@
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { existsSync } from 'fs';
 import { win32 as winPath } from 'path';
 import { homedir } from 'os';

package/dist/git/sync.js

@@ -1,4 +1,4 @@
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { unlinkSync } from 'fs';
 import { join } from 'path';
 export function hasCommits(cwd) {

package/dist/health/checks.js

@@ -1,4 +1,4 @@
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { existsSync, readFileSync } from 'fs';
 import { join, sep } from 'path';
 import { homedir, platform as osPlatform, arch as osArch } from 'os';

package/dist/template/manifest.js

@@ -1,5 +1,5 @@
 import { createHash } from 'crypto';
-import { execFileSync } from 'child_process';
+import { execFileSync } from '../utils/subprocess.js';
 import { readFileSync, writeFileSync, existsSync, readdirSync, mkdirSync } from 'fs';
 import { join, relative } from 'path';
 import { buildIgnoreSets } from '../utils/ignore-matcher.js';

package/dist/utils/agent-guidance.d.ts

@@ -24,6 +24,19 @@ export interface AgentResponse<T> {
 }
 /** Map of key template files and what they're for. */
 export declare const APP_STRUCTURE: Record<string, string>;
+/**
+ * The single most important workflow rule for AI agents working on a
+ * Runwork app. Repeated across multiple guides because it's the
+ * difference between a working dev cycle and a frustrating one.
+ *
+ * Rationale -- agents that don't follow this end up:
+ *   1. Editing files locally with no preview to verify against.
+ *   2. Hitting a single bulk-sync at dev startup that masks which
+ *      change broke what (instead of incremental per-change syncs).
+ *   3. Risking sync conflicts when the local state has diverged from
+ *      the remote in a way the auto-sync can't reconcile.
+ */
+export declare const DEV_FIRST_RULE = "CRITICAL: Always start `runwork dev --detach` BEFORE editing any code in this app. Dev establishes the live sync pipeline -- without it, changes do not flow to the preview, and the dev startup will batch-sync everything at once instead of giving you per-change feedback. To check whether dev is already running for this app, run `runwork info --json` and inspect `localDevSession.state` (alive / stale / none). If alive, just edit. If none or stale, run `runwork dev --detach --json` first, capture the preview URL from the `session_started` event, then proceed with edits.";
 export declare function buildInitGuide(appName: string, dir: string): AgentGuide;
 export declare function buildCloneGuide(appName: string, dir: string): AgentGuide;
 export declare function buildDevSessionGuide(): AgentGuide;

package/dist/utils/agent-guidance.js

@@ -18,7 +18,21 @@ export const APP_STRUCTURE = {
     'blueprint.json': 'App feature registry. Update after adding entities, workflows, agents, etc.',
     'CLAUDE.md': 'Complete framework documentation. Read this before editing anything.',
 };
+/**
+ * The single most important workflow rule for AI agents working on a
+ * Runwork app. Repeated across multiple guides because it's the
+ * difference between a working dev cycle and a frustrating one.
+ *
+ * Rationale -- agents that don't follow this end up:
+ *   1. Editing files locally with no preview to verify against.
+ *   2. Hitting a single bulk-sync at dev startup that masks which
+ *      change broke what (instead of incremental per-change syncs).
+ *   3. Risking sync conflicts when the local state has diverged from
+ *      the remote in a way the auto-sync can't reconcile.
+ */
+export const DEV_FIRST_RULE = 'CRITICAL: Always start `runwork dev --detach` BEFORE editing any code in this app. Dev establishes the live sync pipeline -- without it, changes do not flow to the preview, and the dev startup will batch-sync everything at once instead of giving you per-change feedback. To check whether dev is already running for this app, run `runwork info --json` and inspect `localDevSession.state` (alive / stale / none). If alive, just edit. If none or stale, run `runwork dev --detach --json` first, capture the preview URL from the `session_started` event, then proceed with edits.';
 const COMMON_TIPS = [
+    DEV_FIRST_RULE,
     'Read CLAUDE.md in the app directory first -- it has complete framework documentation with code examples.',
     'You do NOT need to run git commands manually. runwork dev handles file syncing automatically. (git itself must be installed on the system -- see dependencies.)',
     'Do NOT install external AI SDKs (openai, @anthropic-ai/sdk). Use @runworkai/framework/ai instead.',
@@ -39,8 +53,8 @@ export function buildInitGuide(appName, dir) {
         structure: APP_STRUCTURE,
         nextSteps: [
             `cd ${dir}`,
-            'runwork dev  # start development server -- watches for file changes and syncs automatically',
-            'Edit files for your needs (see structure above)',
+            'runwork dev --detach --json  # FIRST: start the dev sandbox in the background; capture the preview URL from the session_started event',
+            'THEN edit files for your needs (see structure above) -- changes auto-sync to the preview',
             'runwork deploy  # deploy to production when ready',
         ],
         tips: COMMON_TIPS,
@@ -53,9 +67,9 @@ export function buildCloneGuide(appName, dir) {
         structure: APP_STRUCTURE,
         nextSteps: [
             `cd ${dir}`,
-            'runwork dev  # start development server',
+            'runwork dev --detach --json  # FIRST: start dev in the background, capture the preview URL',
             'Review existing files to understand what is already built',
-            'Edit files for your needs',
+            'THEN edit files for your needs -- changes auto-sync to the preview',
             'runwork deploy  # deploy to production when ready',
         ],
         tips: [SYSTEM_DEPENDENCIES_NOTE, ...COMMON_TIPS],
@@ -89,17 +103,18 @@ export function buildDeployGuide() {
 }
 export function buildInfoGuide() {
     return {
-        context: 'This shows the current state of the app: what is deployed, what integrations are connected, and what resources (entities, workflows, agents, etc.) are registered.',
+        context: 'This shows the current state of the app: what is deployed, what integrations are connected, and what resources (entities, workflows, agents, etc.) are registered. The `localDevSession` field tells you whether a dev session is already running on this machine -- check it BEFORE starting a new one.',
         nextSteps: [
-            'runwork dev  # start development server if not already running',
+            'If localDevSession.state == "alive": dev is already running. Use the URL in localDevSession.previewUrl and proceed with edits.',
+            'If localDevSession.state == "none" or "stale": run `runwork dev --detach --json` BEFORE editing any code. Capture the preview URL from the session_started event.',
             'runwork deploy  # deploy to production when ready',
         ],
         tips: [
+            DEV_FIRST_RULE,
             'Entities listed here are the data models available via Entity CRUD methods.',
             'Workflows listed here can be triggered via their registered endpoints or schedules.',
             'Agents listed here need frontend pages (conversational) or triggers (task) to be accessible.',
             'Integrations with connected status are ready to use. Others need setup in workspace settings.',
-            'If preview is not active, run runwork dev to start a development session.',
         ],
     };
 }

package/dist/utils/subprocess.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Thin wrappers around `child_process.execFileSync` and `spawn` that
+ * default `windowsHide: true`. On Windows, every console-subsystem
+ * subprocess we spawn (git, where.exe, registry queries) creates its
+ * own console window unless this flag is set. With our hot paths --
+ * auto-commit's git invocations, manifest's `git ls-files`, the sync
+ * loop's git rebase / fetch / push -- a missing flag visibly flashes a
+ * console window every few seconds, which Codex Desktop users see as
+ * "empty terminals keep popping up."
+ *
+ * Use these as drop-in replacements for the `child_process` exports.
+ * Existing options the caller passes still win (so you can opt back to
+ * `windowsHide: false` if you genuinely need the window, e.g. for
+ * interactive prompts -- though we don't have any of those in our
+ * subprocess paths today).
+ */
+import { execFileSync as cpExecFileSync, spawn as cpSpawn } from 'child_process';
+export declare const execFileSync: typeof cpExecFileSync;
+export declare const spawn: typeof cpSpawn;

package/dist/utils/subprocess.js

@@ -0,0 +1,27 @@
+/**
+ * Thin wrappers around `child_process.execFileSync` and `spawn` that
+ * default `windowsHide: true`. On Windows, every console-subsystem
+ * subprocess we spawn (git, where.exe, registry queries) creates its
+ * own console window unless this flag is set. With our hot paths --
+ * auto-commit's git invocations, manifest's `git ls-files`, the sync
+ * loop's git rebase / fetch / push -- a missing flag visibly flashes a
+ * console window every few seconds, which Codex Desktop users see as
+ * "empty terminals keep popping up."
+ *
+ * Use these as drop-in replacements for the `child_process` exports.
+ * Existing options the caller passes still win (so you can opt back to
+ * `windowsHide: false` if you genuinely need the window, e.g. for
+ * interactive prompts -- though we don't have any of those in our
+ * subprocess paths today).
+ */
+import { execFileSync as cpExecFileSync, spawn as cpSpawn, } from 'child_process';
+// We re-export with the *exact* `typeof` signature of the originals so
+// caller-side overload narrowing (encoding -> string vs Buffer return
+// type) keeps working. The implementation forwards through the original
+// after merging in `windowsHide: true` as a default.
+export const execFileSync = ((file, args, options) => {
+    return cpExecFileSync(file, args, { windowsHide: true, ...(options ?? {}) });
+});
+export const spawn = ((command, args, options) => {
+    return cpSpawn(command, args ?? [], { windowsHide: true, ...(options ?? {}) });
+});

package/dist/utils/which.js

@@ -1,4 +1,4 @@
-import { execFileSync } from 'child_process';
+import { execFileSync } from './subprocess.js';
 import { platform } from 'os';
 /**
  * Cross-platform binary detection.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runwork",
-  "version": "0.10.3",
+  "version": "0.10.4",
   "description": "CLI for Runwork: develop, preview, and deploy Runwork apps from your local machine.",
   "license": "UNLICENSED",
   "author": "Runwork <info@runwork.ai> (https://www.runwork.ai)",