runwork 0.13.4 → 0.15.0

package/dist/utils/__tests__/help-json.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { Command } from 'commander';
+import { buildCommandHelpJson } from '../help-json.js';
+function optByFlags(cmd, flags) {
+    const json = buildCommandHelpJson(cmd, '1.0.0');
+    const opt = json.options.find(o => o.flags === flags);
+    if (!opt)
+        throw new Error(`option ${flags} not found`);
+    return opt;
+}
+describe('help-json option required semantics', () => {
+    const cmd = new Command('demo')
+        .option('--workspace <id>', 'workspace id (optional; defaults from credentials)')
+        .option('--flag', 'a boolean flag')
+        .option('--maybe [value]', 'an optional value')
+        .requiredOption('--token <t>', 'a genuinely required option');
+    it('marks a value-taking-but-optional option as NOT required (the --workspace bug)', () => {
+        const o = optByFlags(cmd, '--workspace <id>');
+        expect(o.required).toBe(false); // the option itself is not mandatory
+        expect(o.valueRequired).toBe(true); // but its value is required when present
+        expect(o.optional).toBe(false);
+    });
+    it('marks a boolean flag as neither required nor value-required', () => {
+        const o = optByFlags(cmd, '--flag');
+        expect(o.required).toBe(false);
+        expect(o.valueRequired).toBe(false);
+    });
+    it('marks an optional-value option correctly', () => {
+        const o = optByFlags(cmd, '--maybe [value]');
+        expect(o.required).toBe(false);
+        expect(o.valueRequired).toBe(false);
+        expect(o.optional).toBe(true);
+    });
+    it('marks a genuinely mandatory option as required AND value-required', () => {
+        const o = optByFlags(cmd, '--token <t>');
+        expect(o.required).toBe(true);
+        expect(o.valueRequired).toBe(true);
+    });
+});

package/dist/utils/__tests__/ignore-matcher.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect, afterEach } from 'vitest';
 import { mkdtempSync, writeFileSync, rmSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
-import { buildIgnoreSets, defaultIgnoreSets, isPathIgnored, parseGitignoreContent, } from '../ignore-matcher.js';
+import { buildIgnoreSets, defaultIgnoreSets, isPathIgnored, isRelPathIgnored, parseGitignoreContent, } from '../ignore-matcher.js';
 const tempDirs = [];
 function makeTempDir(prefix) {
     const dir = mkdtempSync(join(tmpdir(), `runwork-ignore-${prefix}-`));
@@ -26,6 +26,23 @@ describe('defaultIgnoreSets()', () => {
         expect(sets.dirs.has('.runwork')).toBe(true);
         expect(sets.dirs.has('.bun-cache')).toBe(true);
     });
+    it('excludes every .runwork/ state file from deploy/dev auto-commit staging', () => {
+        // commitWorkingTree() filters untracked files through isRelPathIgnored,
+        // so any path with a .runwork segment must be excluded -- including the
+        // local deploy-state/status files written before the detached child
+        // commits (Codex review P1).
+        const sets = defaultIgnoreSets();
+        for (const p of [
+            '.runwork/deploy-status.json',
+            '.runwork/last-deploy.json',
+            '.runwork/deploy-stdout.log',
+            '.runwork/dev-session.json',
+            '.runwork/setup.json',
+            '.runwork/preview-url',
+        ]) {
+            expect(isRelPathIgnored(p, sets), `${p} must be ignored`).toBe(true);
+        }
+    });
     it('includes .dev.vars and .env file defaults', () => {
         const sets = defaultIgnoreSets();
         expect(sets.files.has('.dev.vars')).toBe(true);

package/dist/utils/help-json.d.ts

@@ -11,7 +11,21 @@ import type { Command } from 'commander';
 interface JsonOption {
     flags: string;
     description: string;
+    /**
+     * Whether the OPTION itself must be supplied (Commander's `mandatory`, set
+     * via `.makeOptionMandatory()`). This is what an agent reasoning about
+     * "do I have to pass this?" wants. Most options are false here even when
+     * they take a value -- e.g. `--workspace <id>` is optional (defaults from
+     * credentials). Previously this field was wrongly mapped to Commander's
+     * `required` (value-required), which marked nearly every option as required.
+     */
     required: boolean;
+    /**
+     * Whether the option's VALUE is required when the flag is present, i.e. it
+     * was declared with `<value>` (vs `[value]` or a boolean flag). Independent
+     * of whether the option itself must be supplied.
+     */
+    valueRequired: boolean;
     optional: boolean;
     variadic: boolean;
     defaultValue?: unknown;

package/dist/utils/help-json.js

@@ -11,7 +11,10 @@ function serializeOption(opt) {
     const result = {
         flags: opt.flags,
         description: opt.description,
-        required: opt.required,
+        // Commander's `mandatory` = the option must be supplied; `required` = the
+        // option's value is required when present. Expose both, correctly named.
+        required: opt.mandatory,
+        valueRequired: opt.required,
         optional: opt.optional,
         variadic: opt.variadic,
     };

package/dist/validate/__tests__/validate.test.d.ts

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

package/dist/validate/__tests__/validate.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { summarizeFreshness } from '../freshness.js';
+import { detectViteError } from '../preview.js';
+describe('validate/freshness summarizeFreshness()', () => {
+    const base = { localSha: 'a', remoteSha: 'a', ahead: 0, behind: 0, uncommitted: false };
+    it('is in-sync when local==remote, no ahead/behind, clean tree', () => {
+        expect(summarizeFreshness(base).inSync).toBe(true);
+    });
+    it('is not in-sync with uncommitted changes', () => {
+        expect(summarizeFreshness({ ...base, uncommitted: true }).inSync).toBe(false);
+    });
+    it('is not in-sync when ahead of the remote', () => {
+        expect(summarizeFreshness({ ...base, ahead: 2 }).inSync).toBe(false);
+    });
+    it('is not in-sync when behind the remote', () => {
+        expect(summarizeFreshness({ ...base, behind: 1 }).inSync).toBe(false);
+    });
+    it('is not in-sync when there is no remote ref', () => {
+        expect(summarizeFreshness({ ...base, remoteSha: null }).inSync).toBe(false);
+    });
+    it('is not in-sync when there is no local HEAD', () => {
+        expect(summarizeFreshness({ ...base, localSha: null }).inSync).toBe(false);
+    });
+    it('passes through the raw counts', () => {
+        const f = summarizeFreshness({ localSha: 'x', remoteSha: 'y', ahead: 3, behind: 1, uncommitted: true });
+        expect(f).toMatchObject({ ahead: 3, behind: 1, uncommitted: true, inSync: false });
+    });
+});
+describe('validate/preview detectViteError()', () => {
+    it('detects the Vite error overlay element', () => {
+        expect(detectViteError('<vite-error-overlay></vite-error-overlay>')).toBe(true);
+    });
+    it('detects a plugin transform error', () => {
+        expect(detectViteError('[plugin:vite:react-babel] Unexpected token')).toBe(true);
+    });
+    it('detects a failed import resolution', () => {
+        expect(detectViteError('Failed to resolve import "./missing" from "src/App.tsx"')).toBe(true);
+    });
+    it('returns false for a healthy HTML document', () => {
+        expect(detectViteError('<!DOCTYPE html><html><body><div id="root"></div></body></html>')).toBe(false);
+    });
+});

package/dist/validate/freshness.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Git sync-freshness: how the local working tree relates to the deploy remote
+ * (`runwork/main`). Answers "do I have changes that aren't synced/deployed?"
+ * without scraping the sandbox (friction log #10).
+ */
+export interface Freshness {
+    localSha: string | null;
+    remoteSha: string | null;
+    ahead: number;
+    behind: number;
+    uncommitted: boolean;
+    /** true when local == remote and the tree is clean. */
+    inSync: boolean;
+}
+export interface FreshnessInput {
+    localSha: string | null;
+    remoteSha: string | null;
+    ahead: number;
+    behind: number;
+    uncommitted: boolean;
+}
+/** Pure: derive the in-sync verdict from the raw git counts/flags. */
+export declare function summarizeFreshness(input: FreshnessInput): Freshness;
+/**
+ * Collect git freshness for `cwd`. Best-effort fetches `runwork/main` first so
+ * the comparison reflects the real remote tip; tolerates offline/no-remote.
+ */
+export declare function getGitFreshness(cwd: string): Freshness;

package/dist/validate/freshness.js

@@ -0,0 +1,48 @@
+import { execFileSync } from '../utils/subprocess.js';
+/** Pure: derive the in-sync verdict from the raw git counts/flags. */
+export function summarizeFreshness(input) {
+    const inSync = input.localSha !== null &&
+        input.remoteSha !== null &&
+        input.ahead === 0 &&
+        input.behind === 0 &&
+        !input.uncommitted;
+    return { ...input, inSync };
+}
+function gitOut(cwd, args) {
+    try {
+        return execFileSync('git', args, { cwd, stdio: ['ignore', 'pipe', 'ignore'] }).toString().trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Collect git freshness for `cwd`. Best-effort fetches `runwork/main` first so
+ * the comparison reflects the real remote tip; tolerates offline/no-remote.
+ */
+export function getGitFreshness(cwd) {
+    // Best-effort: refresh the remote-tracking ref. Failure (offline, no remote)
+    // just means we compare against whatever ref we already have.
+    try {
+        execFileSync('git', ['fetch', 'runwork', 'main'], { cwd, stdio: 'pipe' });
+    }
+    catch {
+        /* offline or no runwork remote -- non-fatal */
+    }
+    const localSha = gitOut(cwd, ['rev-parse', 'HEAD']);
+    const remoteSha = gitOut(cwd, ['rev-parse', 'runwork/main']);
+    let ahead = 0;
+    let behind = 0;
+    if (localSha && remoteSha) {
+        // `<behind>\t<ahead>` relative to runwork/main...HEAD
+        const counts = gitOut(cwd, ['rev-list', '--left-right', '--count', 'runwork/main...HEAD']);
+        if (counts) {
+            const [b, a] = counts.split(/\s+/).map(n => parseInt(n, 10));
+            behind = Number.isFinite(b) ? b : 0;
+            ahead = Number.isFinite(a) ? a : 0;
+        }
+    }
+    const porcelain = gitOut(cwd, ['status', '--porcelain']);
+    const uncommitted = porcelain !== null && porcelain.length > 0;
+    return summarizeFreshness({ localSha, remoteSha, ahead, behind, uncommitted });
+}

package/dist/validate/preview.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Liveness of the preview deployment: does it respond, and is it serving a
+ * working build (vs a Vite error overlay)? This is the cheap "is my change
+ * live and compiling" signal the friction log (#10) reached for by hand.
+ */
+export interface PreviewLiveness {
+    url: string | null;
+    responds: boolean;
+    status: number | null;
+    /** A Vite/build error overlay was detected in the served HTML. */
+    errorDetected: boolean;
+    error?: string;
+}
+/**
+ * Heuristically detect a Vite dev-server error overlay / transform error in
+ * served HTML. These are the markers Vite injects when a module fails to
+ * compile, so their presence means the preview is serving a broken build.
+ */
+export declare function detectViteError(html: string): boolean;
+/** Fetch the preview URL and report whether it's live and error-free. */
+export declare function checkPreview(url: string | null): Promise<PreviewLiveness>;

package/dist/validate/preview.js

@@ -0,0 +1,39 @@
+import { httpFetch } from '../utils/http.js';
+/**
+ * Heuristically detect a Vite dev-server error overlay / transform error in
+ * served HTML. These are the markers Vite injects when a module fails to
+ * compile, so their presence means the preview is serving a broken build.
+ */
+export function detectViteError(html) {
+    const markers = [
+        'vite-error-overlay',
+        'class="vite-error',
+        '[vite] Internal Server Error',
+        '[plugin:vite:',
+        'Pre-transform error',
+        'Failed to resolve import',
+        'Internal server error:',
+    ];
+    return markers.some(m => html.includes(m));
+}
+/** Fetch the preview URL and report whether it's live and error-free. */
+export async function checkPreview(url) {
+    if (!url) {
+        return { url: null, responds: false, status: null, errorDetected: false };
+    }
+    try {
+        const res = await httpFetch(url, { method: 'GET' });
+        let errorDetected = false;
+        try {
+            const body = await res.text();
+            errorDetected = detectViteError(body);
+        }
+        catch {
+            /* body read failed -- treat as no overlay detected */
+        }
+        return { url, responds: res.status > 0 && res.status < 500, status: res.status, errorDetected };
+    }
+    catch (err) {
+        return { url, responds: false, status: null, errorDetected: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runwork",
-  "version": "0.13.4",
+  "version": "0.15.0",
   "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)",