runwork 0.15.0 → 0.15.2

package/dist/git/critical-files.d.ts

@@ -1,20 +0,0 @@
-/**
- * Files that must survive a remote sync. The sync path can rebase or, as a
- * last resort, merge with `-X theirs` (remote wins) to reconcile diverged
- * histories. If the remote tip is missing one of these (e.g. right after a
- * fresh init, or a server-side reconcile), the merge can delete the local
- * copy. Losing `.runwork.json` in particular bricks the app for the CLI
- * ("not a Runwork app"). We snapshot these before the sync and restore any
- * the sync removed.
- *
- * Shared by `runwork dev` (startup sync) and `runwork deploy` so both protect
- * the same set with identical logic.
- */
-export declare const CRITICAL_FILES: readonly [".runwork.json", "blueprint.json", ".gitignore"];
-export interface CriticalSnapshot {
-    path: string;
-    contents: string;
-}
-export declare function snapshotCriticalFiles(cwd: string): CriticalSnapshot[];
-export declare function restoreMissingCriticalFiles(cwd: string, snapshots: CriticalSnapshot[]): string[];
-export declare function commitAndPushRestoredFiles(cwd: string, files: string[]): boolean;

package/dist/git/critical-files.js

@@ -1,68 +0,0 @@
-import { execFileSync } from '../utils/subprocess.js';
-import { readFileSync, writeFileSync, existsSync } from 'fs';
-import { join } from 'path';
-/**
- * Files that must survive a remote sync. The sync path can rebase or, as a
- * last resort, merge with `-X theirs` (remote wins) to reconcile diverged
- * histories. If the remote tip is missing one of these (e.g. right after a
- * fresh init, or a server-side reconcile), the merge can delete the local
- * copy. Losing `.runwork.json` in particular bricks the app for the CLI
- * ("not a Runwork app"). We snapshot these before the sync and restore any
- * the sync removed.
- *
- * Shared by `runwork dev` (startup sync) and `runwork deploy` so both protect
- * the same set with identical logic.
- */
-export const CRITICAL_FILES = ['.runwork.json', 'blueprint.json', '.gitignore'];
-export function snapshotCriticalFiles(cwd) {
-    const snapshots = [];
-    for (const rel of CRITICAL_FILES) {
-        const abs = join(cwd, rel);
-        if (!existsSync(abs))
-            continue;
-        try {
-            snapshots.push({ path: rel, contents: readFileSync(abs, 'utf-8') });
-        }
-        catch {
-            // Best-effort: skip unreadable files.
-        }
-    }
-    return snapshots;
-}
-export function restoreMissingCriticalFiles(cwd, snapshots) {
-    const restored = [];
-    for (const snap of snapshots) {
-        const abs = join(cwd, snap.path);
-        if (existsSync(abs))
-            continue;
-        try {
-            writeFileSync(abs, snap.contents, 'utf-8');
-            restored.push(snap.path);
-        }
-        catch {
-            // Best-effort: skip files we cannot write back.
-        }
-    }
-    return restored;
-}
-export function commitAndPushRestoredFiles(cwd, files) {
-    if (files.length === 0)
-        return false;
-    try {
-        execFileSync('git', ['add', '--', ...files], { cwd, stdio: 'pipe' });
-        execFileSync('git', ['commit', '-m', 'chore: restore critical files removed by sync'], { cwd, stdio: 'pipe' });
-    }
-    catch {
-        return false;
-    }
-    try {
-        // `HEAD:main` so the push works regardless of local branch name.
-        execFileSync('git', ['push', 'runwork', 'HEAD:main'], { cwd, stdio: 'pipe' });
-        return true;
-    }
-    catch {
-        // Push failures are non-fatal: the local copy is restored, and the
-        // restoration commit will be pushed with the next auto-sync cycle.
-        return false;
-    }
-}

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

@@ -1,53 +0,0 @@
-/**
- * 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

@@ -1,78 +0,0 @@
-/**
- * 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/git/identity.d.ts

@@ -1,44 +0,0 @@
-import type { Credentials } from '../types.js';
-/**
- * Derive a human-friendly display name from an email address. Used when the
- * credentials store only has the email (which is the common case). e.g.
- * "oytun@motaword.com" -> "Oytun"; "anna.maria@example.com" -> "Anna Maria".
- */
-declare function deriveNameFromEmail(email: string): string;
-declare function pickIdentity(creds?: Credentials | null): {
-    email: string;
-    name: string;
-};
-/**
- * Ensure the repository at `cwd` has a usable git identity (user.email and
- * user.name) and that, whenever possible, commits are attributed to the
- * authenticated Runwork user.
- *
- * Precedence:
- *   1. If we have usable Runwork credentials, always write local-scoped
- *      `user.email` / `user.name` from those credentials. Commits to a
- *      Runwork remote should be attributable to the logged-in Runwork user,
- *      not to whatever generic identity the developer uses for unrelated
- *      personal repos.
- *   2. If credentials are missing or are an unusable placeholder
- *      (e.g. API-key login), fall back to any existing global / system
- *      configuration so the user's pre-existing identity still works.
- *   3. If neither credentials nor any existing config are available, write a
- *      synthetic local identity so the inevitable `git commit` does not fail
- *      on a fresh Windows / minimal-container install with the classic
- *      `unable to auto-detect email address` error.
- *
- * Local scope (`git config --local`) is mandatory: we never touch the user's
- * global config so we cannot disturb identities they use elsewhere.
- *
- * Safe to call multiple times; it short-circuits when the desired identity
- * is already in place.
- */
-export declare function ensureGitIdentity(cwd: string, creds?: Credentials | null): void;
-export declare const __testing: {
-    deriveNameFromEmail: typeof deriveNameFromEmail;
-    pickIdentity: typeof pickIdentity;
-    FALLBACK_EMAIL: string;
-    FALLBACK_NAME: string;
-};
-export {};

package/dist/git/identity.js

@@ -1,133 +0,0 @@
-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,
- * so it does not leak into other repositories on the user's machine.
- */
-const FALLBACK_EMAIL = 'runwork-cli@runwork.local';
-const FALLBACK_NAME = 'Runwork User';
-/**
- * Derive a human-friendly display name from an email address. Used when the
- * credentials store only has the email (which is the common case). e.g.
- * "oytun@motaword.com" -> "Oytun"; "anna.maria@example.com" -> "Anna Maria".
- */
-function deriveNameFromEmail(email) {
-    const local = email.split('@')[0] ?? '';
-    if (!local)
-        return FALLBACK_NAME;
-    const cleaned = local.replace(/[._+-]+/g, ' ').trim();
-    if (!cleaned)
-        return FALLBACK_NAME;
-    return cleaned
-        .split(/\s+/)
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(' ');
-}
-function isUsableEmail(value) {
-    if (!value)
-        return false;
-    // Reject the "api-key-auth" placeholder used by API-key login flows.
-    if (!value.includes('@'))
-        return false;
-    return true;
-}
-function pickIdentity(creds) {
-    const email = isUsableEmail(creds?.email) ? creds.email : FALLBACK_EMAIL;
-    const name = email === FALLBACK_EMAIL ? FALLBACK_NAME : deriveNameFromEmail(email);
-    return { email, name };
-}
-function readGitConfig(cwd, key) {
-    try {
-        const value = execFileSync('git', ['config', '--get', key], { cwd, stdio: ['ignore', 'pipe', 'ignore'] });
-        return value.toString('utf-8').trim();
-    }
-    catch {
-        return '';
-    }
-}
-function readLocalGitConfig(cwd, key) {
-    try {
-        const value = execFileSync('git', ['config', '--local', '--get', key], { cwd, stdio: ['ignore', 'pipe', 'ignore'] });
-        return value.toString('utf-8').trim();
-    }
-    catch {
-        return '';
-    }
-}
-/**
- * Ensure the repository at `cwd` has a usable git identity (user.email and
- * user.name) and that, whenever possible, commits are attributed to the
- * authenticated Runwork user.
- *
- * Precedence:
- *   1. If we have usable Runwork credentials, always write local-scoped
- *      `user.email` / `user.name` from those credentials. Commits to a
- *      Runwork remote should be attributable to the logged-in Runwork user,
- *      not to whatever generic identity the developer uses for unrelated
- *      personal repos.
- *   2. If credentials are missing or are an unusable placeholder
- *      (e.g. API-key login), fall back to any existing global / system
- *      configuration so the user's pre-existing identity still works.
- *   3. If neither credentials nor any existing config are available, write a
- *      synthetic local identity so the inevitable `git commit` does not fail
- *      on a fresh Windows / minimal-container install with the classic
- *      `unable to auto-detect email address` error.
- *
- * Local scope (`git config --local`) is mandatory: we never touch the user's
- * global config so we cannot disturb identities they use elsewhere.
- *
- * Safe to call multiple times; it short-circuits when the desired identity
- * is already in place.
- */
-export function ensureGitIdentity(cwd, creds) {
-    // Only act on actual git repos; refuse silently if `cwd` has no .git.
-    try {
-        execFileSync('git', ['rev-parse', '--git-dir'], { cwd, stdio: 'pipe' });
-    }
-    catch {
-        return;
-    }
-    const credsUsable = isUsableEmail(creds?.email);
-    // Path 1: real Runwork credentials -- always overwrite local config so the
-    // commit is attributed to the Runwork user, regardless of global state.
-    if (credsUsable) {
-        const { email, name } = pickIdentity(creds);
-        const existingLocalEmail = readLocalGitConfig(cwd, 'user.email');
-        const existingLocalName = readLocalGitConfig(cwd, 'user.name');
-        if (existingLocalEmail !== email) {
-            try {
-                execFileSync('git', ['config', '--local', 'user.email', email], { cwd, stdio: 'pipe' });
-            }
-            catch { /* read-only fs */ }
-        }
-        if (existingLocalName !== name) {
-            try {
-                execFileSync('git', ['config', '--local', 'user.name', name], { cwd, stdio: 'pipe' });
-            }
-            catch { /* read-only fs */ }
-        }
-        return;
-    }
-    // Path 2: no usable creds. Respect any pre-existing identity (global/local).
-    const existingEmail = readGitConfig(cwd, 'user.email');
-    const existingName = readGitConfig(cwd, 'user.name');
-    if (existingEmail && existingName)
-        return;
-    // Path 3: no creds AND no existing identity -- seed a synthetic fallback
-    // so commits do not fail on a fresh machine.
-    const { email, name } = pickIdentity(creds);
-    if (!existingEmail) {
-        try {
-            execFileSync('git', ['config', '--local', 'user.email', email], { cwd, stdio: 'pipe' });
-        }
-        catch { /* read-only fs */ }
-    }
-    if (!existingName) {
-        try {
-            execFileSync('git', ['config', '--local', 'user.name', name], { cwd, stdio: 'pipe' });
-        }
-        catch { /* read-only fs */ }
-    }
-}
-// Exported for unit tests so we do not have to re-derive expectations there.
-export const __testing = { deriveNameFromEmail, pickIdentity, FALLBACK_EMAIL, FALLBACK_NAME };

package/dist/git/preflight.d.ts

@@ -1,57 +0,0 @@
-export type GitSource = 'PATH' | 'where' | 'registry' | 'canonical';
-export interface GitProbe {
-    installed: boolean;
-    /** Trimmed `git --version` output when detected; undefined otherwise. */
-    version?: string;
-    /** Resolved binary path; 'git' when bare PATH lookup worked, absolute when discovered via fallback. */
-    path?: string;
-    /** How we resolved the binary -- useful for `runwork doctor --verbose` diagnostics. */
-    source?: GitSource;
-    /** Underlying error for diagnostics (most often ENOENT on a missing git binary). */
-    error?: NodeJS.ErrnoException;
-}
-/**
- * Probe whether `git` is callable from this process.
- *
- * Strategy:
- *   1. Try a bare `git --version` -- the common path on macOS, Linux, and
- *      most Windows installs.
- *   2. On Windows, fall back to `where.exe git` (uses the same PATH +
- *      PATHEXT rules cmd.exe applies, which are more permissive than
- *      Bun's spawn lookup in standalone-compiled binaries).
- *   3. On Windows, finally probe canonical install paths under
- *      %ProgramFiles%, %ProgramFiles(x86)%, %LOCALAPPDATA%\Programs.
- *
- * When step 2 or 3 succeeds, we prepend the resolved directory to
- * process.env.PATH so the ~50 other call sites that do
- * `execFileSync('git', ...)` automatically benefit, without rewriting
- * each one. Result is cached for the lifetime of the process.
- */
-export declare function probeGit(): GitProbe;
-/**
- * Reset the cached probe result. Exposed for tests and for `runwork doctor`
- * when it wants to re-check after a guided install.
- */
-export declare function resetGitProbeCache(): void;
-/**
- * Extract a short numeric version (e.g. "2.43.0") from a `git --version`
- * output line. Returns null if no number could be parsed.
- */
-export declare function parseGitVersion(versionLine: string | undefined): string | null;
-/**
- * Build a beginner-friendly message explaining how to recover from a missing
- * git binary. Includes a Windows-specific hint because the most common
- * scenario there is "winget install Git.Git just succeeded but this shell's
- * PATH was cached at launch" -- restarting the shell fixes it without a
- * second install attempt.
- *
- * If a probe error is supplied, the underlying message is appended so users
- * can see *why* detection failed (ENOENT vs EACCES vs something else).
- */
-export declare function buildMissingGitMessage(commandName: string, probe?: GitProbe): string;
-/**
- * Convenience wrapper for command entry points: probe git, and if it's
- * missing, print the beginner-friendly message and exit with code 1.
- * Returns void on success so callers can early-return on failure.
- */
-export declare function requireGit(commandName: string): void;