runwork 0.13.3 → 0.13.4

package/dist/git/deploy-guard.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Deploy guard: detect whether `runwork deploy` is about to commit and
+ * deploy code that the preview does not reflect, and decide whether to
+ * warn the user about it.
+ *
+ * The preview reflects the last *pushed* commit. When an auto-syncing
+ * `runwork dev` session is running, its file watcher commits and pushes
+ * continuously, so the working tree, the remote, and the preview stay in
+ * lockstep and there is nothing to warn about. But when there is no
+ * session, or the session is `--no-sync` (manual git), a dirty or
+ * ahead-of-remote working tree means the deploy will ship code the user
+ * never saw in the preview. That is the case we warn on.
+ *
+ * The pure decision (`shouldWarnBeforeDeploy`) is separated from the git
+ * and session IO so it can be unit-tested without a repo or session file.
+ */
+import { type SessionState } from '../dev/session.js';
+export interface WorkingTreeStatus {
+    /** `git status --porcelain` reported at least one entry (tracked or untracked). */
+    dirty: boolean;
+    /** Local HEAD has commits not present on `runwork/main`. */
+    ahead: boolean;
+}
+/**
+ * Whether the working tree diverges from what the preview shows.
+ * "Dirty" = uncommitted changes; "ahead" = committed but unpushed.
+ */
+export declare function isDirtyOrAhead(status: WorkingTreeStatus): boolean;
+/**
+ * Decide whether to warn before deploying.
+ *
+ * We warn only when the tree diverges from the preview AND no
+ * auto-syncing dev session is keeping things in lockstep. A live session
+ * whose `noSync` is not true owns commits/pushes, so it is suppressed; a
+ * `noSync` session (or no session at all) does not, so we warn.
+ */
+export declare function shouldWarnBeforeDeploy(status: WorkingTreeStatus, session: SessionState): boolean;
+/**
+ * Probe the working tree via git. `dirty` includes untracked files (a new
+ * file the user added is still not in the preview). `ahead` counts local
+ * commits not on `runwork/main`; a missing remote ref is treated as not
+ * ahead (no baseline to compare against, and the push step handles it).
+ */
+export declare function readWorkingTreeStatus(cwd: string): WorkingTreeStatus;
+/**
+ * End-to-end guard decision against the real repo and session file.
+ * Returns the status alongside the warn decision so callers can include
+ * the specifics (dirty / ahead) in their message.
+ */
+export declare function evaluateDeployGuard(cwd: string, appId: string): {
+    status: WorkingTreeStatus;
+    warn: boolean;
+};

package/dist/git/deploy-guard.js

@@ -0,0 +1,78 @@
+/**
+ * Deploy guard: detect whether `runwork deploy` is about to commit and
+ * deploy code that the preview does not reflect, and decide whether to
+ * warn the user about it.
+ *
+ * The preview reflects the last *pushed* commit. When an auto-syncing
+ * `runwork dev` session is running, its file watcher commits and pushes
+ * continuously, so the working tree, the remote, and the preview stay in
+ * lockstep and there is nothing to warn about. But when there is no
+ * session, or the session is `--no-sync` (manual git), a dirty or
+ * ahead-of-remote working tree means the deploy will ship code the user
+ * never saw in the preview. That is the case we warn on.
+ *
+ * The pure decision (`shouldWarnBeforeDeploy`) is separated from the git
+ * and session IO so it can be unit-tested without a repo or session file.
+ */
+import { execFileSync } from '../utils/subprocess.js';
+import { getSessionState } from '../dev/session.js';
+/**
+ * Whether the working tree diverges from what the preview shows.
+ * "Dirty" = uncommitted changes; "ahead" = committed but unpushed.
+ */
+export function isDirtyOrAhead(status) {
+    return status.dirty || status.ahead;
+}
+/**
+ * Decide whether to warn before deploying.
+ *
+ * We warn only when the tree diverges from the preview AND no
+ * auto-syncing dev session is keeping things in lockstep. A live session
+ * whose `noSync` is not true owns commits/pushes, so it is suppressed; a
+ * `noSync` session (or no session at all) does not, so we warn.
+ */
+export function shouldWarnBeforeDeploy(status, session) {
+    if (!isDirtyOrAhead(status))
+        return false;
+    if (session.state === 'alive' && session.file.noSync !== true) {
+        // An auto-syncing watcher keeps the preview in lockstep with the tree.
+        return false;
+    }
+    return true;
+}
+/**
+ * Probe the working tree via git. `dirty` includes untracked files (a new
+ * file the user added is still not in the preview). `ahead` counts local
+ * commits not on `runwork/main`; a missing remote ref is treated as not
+ * ahead (no baseline to compare against, and the push step handles it).
+ */
+export function readWorkingTreeStatus(cwd) {
+    let dirty = false;
+    try {
+        const porcelain = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf-8' });
+        dirty = porcelain.trim().length > 0;
+    }
+    catch {
+        // Not a git repo yet, or git unavailable. Nothing meaningful to warn about.
+    }
+    let ahead = false;
+    try {
+        const count = execFileSync('git', ['rev-list', '--count', 'runwork/main..HEAD'], { cwd, encoding: 'utf-8' });
+        ahead = parseInt(count.trim(), 10) > 0;
+    }
+    catch {
+        // `runwork/main` does not exist locally (never fetched) or no HEAD yet.
+        // Treat as not ahead: there is no pushed baseline to diverge from.
+    }
+    return { dirty, ahead };
+}
+/**
+ * End-to-end guard decision against the real repo and session file.
+ * Returns the status alongside the warn decision so callers can include
+ * the specifics (dirty / ahead) in their message.
+ */
+export function evaluateDeployGuard(cwd, appId) {
+    const status = readWorkingTreeStatus(cwd);
+    const session = getSessionState(cwd, appId);
+    return { status, warn: shouldWarnBeforeDeploy(status, session) };
+}

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

@@ -21,6 +21,8 @@ export interface AgentResponse<T> {
     result: T;
     guide?: AgentGuide;
     error?: AgentError;
+    /** Non-blocking advisory surfaced alongside a successful result. */
+    warning?: string;
 }
 /** Map of key template files and what they're for. */
 export declare const APP_STRUCTURE: Record<string, string>;

package/dist/utils/ignore-matcher.d.ts

@@ -35,4 +35,13 @@ export declare function buildIgnoreSets(dir: string): IgnoreSets;
  * recursive directory walkers without needing absolute-path bookkeeping.
  */
 export declare function isPathIgnored(filePath: string, sets: IgnoreSets): boolean;
+/**
+ * Like isPathIgnored, but for a full repo-relative path (e.g. the output of
+ * `git ls-files`) rather than a single traversal step. It also treats a path
+ * as ignored when ANY parent directory segment is an ignored dir (e.g.
+ * `worker/.bun-cache/x.js`). The chokidar watcher gets this for free because
+ * it never descends into an ignored directory; a flat path list does not, so
+ * callers staging untracked files must use this variant to match the watcher.
+ */
+export declare function isRelPathIgnored(relPath: string, sets: IgnoreSets): boolean;
 export {};

package/dist/utils/ignore-matcher.js

@@ -114,3 +114,19 @@ export function isPathIgnored(filePath, sets) {
     }
     return false;
 }
+/**
+ * Like isPathIgnored, but for a full repo-relative path (e.g. the output of
+ * `git ls-files`) rather than a single traversal step. It also treats a path
+ * as ignored when ANY parent directory segment is an ignored dir (e.g.
+ * `worker/.bun-cache/x.js`). The chokidar watcher gets this for free because
+ * it never descends into an ignored directory; a flat path list does not, so
+ * callers staging untracked files must use this variant to match the watcher.
+ */
+export function isRelPathIgnored(relPath, sets) {
+    const segments = relPath.split('/');
+    for (let i = 0; i < segments.length - 1; i++) {
+        if (sets.dirs.has(segments[i]))
+            return true;
+    }
+    return isPathIgnored(relPath, sets);
+}

package/package.json

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