specrails-desktop 2.24.0 → 2.24.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specrails-desktop",
-  "version": "2.24.0",
+  "version": "2.24.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/server/dist/claude-trust.js

@@ -36,26 +36,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.claudeConfigPath = claudeConfigPath;
 exports.markProjectsTrusted = markProjectsTrusted;
 exports.ensureClaudeTrusted = ensureClaudeTrusted;
-exports.__resetClaudeTrustMemoForTest = __resetClaudeTrustMemoForTest;
 /**
  * Pre-trust specrails-managed spawn directories in the user's `~/.claude.json`
- * so a HEADLESS claude rail/job spawn honours the `.claude/settings.json`
- * `permissions.allow` list the framework overlay places in the worktree.
- *
- * Why: claude ignores a workspace's `permissions.allow` entries until that
- * project directory has been "trusted" (the interactive trust dialog, or
- * `projects[<dir>].hasTrustDialogAccepted: true` in `~/.claude.json`). specrails
- * spawns claude headlessly in FRESH per-run worktrees / workspaces that were
- * never opened interactively, so every isolated rail run logged
+ * so a HEADLESS claude rail/job spawn does NOT log the noisy
  * "Ignoring N permissions.allow entries … this workspace has not been trusted"
- * and ran with its pre-approved permissions silently dropped. We manage those
- * directories, so pre-marking them trusted is correct and safe.
+ * warning.
+ *
+ * IMPORTANT — this is cosmetic, not load-bearing. Every claude spawn already
+ * carries `--dangerously-skip-permissions` (see `claude-adapter.ts` COMMON_FLAGS),
+ * which bypasses the permission engine entirely — so a workspace's
+ * `.claude/settings.json` `permissions.allow` list is moot on these spawns
+ * whether the dir is trusted or not. Marking the dir trusted only silences the
+ * warning. (It WOULD become functionally load-bearing if we ever dropped
+ * `--dangerously-skip-permissions` and relied on the allow-list.)
+ *
+ * Why re-assert on EVERY spawn (no persistent memo): `~/.claude.json` is a
+ * single ~200KB file holding ALL projects that many concurrent claude processes
+ * rewrite wholesale (each carries its own in-memory snapshot). Our surgical
+ * `true` for one dir is routinely clobbered by another process writing the whole
+ * file back with a stale `false` — a lost update. A one-shot per-process memo
+ * (the old design) therefore left the flag stuck `false` for the rest of the
+ * process lifetime after the first clobber. Re-asserting immediately before each
+ * spawn re-flips a clobbered `false → true` so this spawn reads `true` at
+ * startup. It cannot fully win the race against concurrent whole-file writers,
+ * but the failure mode is only a cosmetic warning, so best-effort is enough.
  *
  * Surgical + best-effort: read → set only `hasTrustDialogAccepted` on the
  * relevant `projects[<realpath>]` keys → atomic temp+rename. Never throws, never
  * touches any other field, and only writes when something actually changed.
- * claude-only (the trust/allow model is a claude concept). Memoized per path so
- * a multi-step run does the I/O once, before the first spawn in that dir.
+ * claude-only (the trust/allow model is a claude concept).
  */
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -122,17 +131,21 @@ function markProjectsTrusted(configPath, dirs) {
     }
     return changed;
 }
-// Per-path memo so a multi-step run writes at most once per unique dir.
-const _trusted = new Set();
 /**
- * Ensure the claude spawn directories are trusted, once per process per dir.
- * No-op for non-claude providers and best-effort otherwise (a failure only
- * means the pre-approved permissions stay dropped — never blocks a spawn).
+ * Ensure the claude spawn directories are trusted, RE-ASSERTED on every call
+ * (no persistent memo — see the module header for why: concurrent whole-file
+ * writers clobber our flag back to `false`, and a one-shot memo would leave it
+ * stuck). No-op for non-claude providers and best-effort otherwise (a failure
+ * only leaves the cosmetic trust warning — never blocks a spawn).
+ *
+ * `markProjectsTrusted` reads the current on-disk value and writes ONLY when a
+ * dir is missing / `false`, so a call where the flag is already `true` is a
+ * cheap read with no write.
  */
 function ensureClaudeTrusted(provider, dirs, home) {
     if (provider !== 'claude')
         return;
-    const todo = dirs.filter((d) => !!d && !_trusted.has(canonical(d)));
+    const todo = dirs.filter((d) => !!d);
     if (todo.length === 0)
         return;
     try {
@@ -141,10 +154,4 @@ function ensureClaudeTrusted(provider, dirs, home) {
     catch {
         /* best-effort */
     }
-    for (const d of todo)
-        _trusted.add(canonical(d));
-}
-/** Test-only: clear the per-path memo. */
-function __resetClaudeTrustMemoForTest() {
-    _trusted.clear();
 }

package/server/dist/integration-branch.js

@@ -1,9 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FETCH_ORIGIN_TTL_MS = void 0;
+exports.__resetFetchOriginCache = __resetFetchOriginCache;
+exports.fetchOrigin = fetchOrigin;
 exports.repoDefaultBranch = repoDefaultBranch;
 exports.currentBranch = currentBranch;
 exports.isValidBranchName = isValidBranchName;
 exports.resolveIntegrationBranch = resolveIntegrationBranch;
+exports.resolveWorktreeBaseRef = resolveWorktreeBaseRef;
+/** How long a fetch outcome (success OR failure) is reused for the same repo
+ *  before a fresh `git fetch origin` is attempted again. Exists so a burst of
+ *  near-simultaneous launches against the SAME repo — e.g. a "Launch all"
+ *  batch, which is N independent HTTP requests with no shared server-side
+ *  transaction (see design.md Decision 2) — performs one real fetch instead of
+ *  one per rail. */
+exports.FETCH_ORIGIN_TTL_MS = 15_000;
+const fetchCache = new Map();
+/** Test-only: clear the fetch dedup cache so tests never leak state across
+ *  cases (mirrors `__resetRepoLocks` in repo-lock.ts). */
+function __resetFetchOriginCache() {
+    fetchCache.clear();
+}
+/**
+ * `git fetch origin` against `repoDir` — updates ONLY `refs/remotes/origin/*`,
+ * never the checked-out local branch or working tree (Git itself refuses to
+ * touch either via a plain fetch). Never throws: any non-zero exit or runner
+ * rejection resolves to `{ ok: false, error }` so callers can degrade
+ * gracefully instead of failing the launch.
+ *
+ * De-duped per `repoDir` for `FETCH_ORIGIN_TTL_MS`: a call within the window
+ * of the last attempt (success OR failure) for the same repo reuses that
+ * outcome instead of spawning a new `git fetch` process. `now` is injectable
+ * so tests can control TTL expiry without real timers.
+ */
+async function fetchOrigin(git, repoDir, now = Date.now) {
+    const cached = fetchCache.get(repoDir);
+    const nowMs = now();
+    if (cached && nowMs - cached.at < exports.FETCH_ORIGIN_TTL_MS)
+        return cached.result;
+    const result = (async () => {
+        try {
+            const r = await git.run(['fetch', 'origin'], repoDir);
+            if (r.code === 0)
+                return { ok: true };
+            return { ok: false, error: r.stderr.trim() || r.stdout.trim() || `exit ${r.code}` };
+        }
+        catch (err) {
+            return { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    })();
+    fetchCache.set(repoDir, { at: nowMs, result });
+    return result;
+}
 /** The repo's default branch via `origin/HEAD` → the bare branch name, or null. */
 async function repoDefaultBranch(git, repoDir) {
     const r = await git.run(['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD'], repoDir);
@@ -61,3 +109,35 @@ async function resolveIntegrationBranch(git, input) {
     // Detached / no remote / unresolvable → the literal HEAD (legacy-identical).
     return { branch: 'HEAD', source: 'head-fallback' };
 }
+/**
+ * Decide the actual `baseRef` a worktree should branch from, given the
+ * already-resolved integration branch and whether `fetchOrigin` succeeded.
+ *
+ * `explicit` is a launch-time override the caller chose on purpose — it is
+ * NEVER remote-prefixed and NEVER existence-checked (see proposal.md Out of
+ * Scope). Every other source (`repo-default`, `project-setting`,
+ * `head-fallback`) uses the fetched remote-tracking ref `origin/<branch>`
+ * ONLY when the fetch succeeded AND that remote branch actually exists —
+ * guards a `project-setting` branch that was never pushed, which would
+ * otherwise turn a working local-only setup into a broken `git worktree add`.
+ * Any failure of either check falls back to today's bare local branch name,
+ * with a human-readable `warning` the caller can log/broadcast.
+ */
+async function resolveWorktreeBaseRef(git, input) {
+    const { repoDir, integration, fetchOk } = input;
+    if (integration.source === 'explicit') {
+        return { baseRef: integration.branch, usedRemote: false };
+    }
+    if (!fetchOk) {
+        return { baseRef: integration.branch, usedRemote: false, warning: 'git fetch origin failed; using local ref' };
+    }
+    const exists = await git.run(['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${integration.branch}`], repoDir);
+    if (exists.code === 0) {
+        return { baseRef: `origin/${integration.branch}`, usedRemote: true };
+    }
+    return {
+        baseRef: integration.branch,
+        usedRemote: false,
+        warning: `origin/${integration.branch} not found; using local ref`,
+    };
+}

package/server/dist/pr-publisher.js

@@ -23,10 +23,18 @@ exports.publishDraftPr = publishDraftPr;
  */
 const child_process_1 = require("child_process");
 const git_guardrails_1 = require("./git-guardrails");
+const win_spawn_1 = require("./util/win-spawn");
 exports.defaultExec = {
     run(cmd, args, cwd) {
         return new Promise((resolve) => {
-            (0, child_process_1.execFile)(cmd, args, { cwd, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => {
+            // `windowsSpawnEnv()` backfills SystemRoot / ComSpec / USERPROFILE, which a
+            // GUI-launched / pkg-stripped Windows sidecar can lack — without them the
+            // `git`/`gh` child (and the `sh -c` the `!gh …` credential helper runs) can
+            // fail to start. NOT `GIT_EXEC_ENV`: that hardened env disables credentials
+            // (GIT_ASKPASS=echo / GIT_TERMINAL_PROMPT=0), which the push must keep. No-op
+            // on POSIX (returns process.env), so mac/Linux behaviour is byte-identical.
+            const env = (0, win_spawn_1.windowsSpawnEnv)();
+            (0, child_process_1.execFile)(cmd, args, { cwd, env, maxBuffer: 16 * 1024 * 1024, windowsHide: true }, (err, stdout, stderr) => {
                 const code = err && typeof err.code === 'number' ? err.code : err ? 1 : 0;
                 resolve({ code, stdout: stdout?.toString() ?? '', stderr: stderr?.toString() ?? '' });
             });
@@ -45,7 +53,22 @@ async function publishDraftPr(exec, input) {
     //    Guardrail: never force-push, never push the integration branch itself.
     const pushArgs = ['push', '-u', remote, branch];
     (0, git_guardrails_1.assertGitAllowed)('git', pushArgs, { protectedBranch: baseBranch });
-    const push = await exec.run('git', pushArgs, repoDir);
+    let push = await exec.run('git', pushArgs, repoDir);
+    if (push.code !== 0 && isCredentialFailure(push)) {
+        // The push failed authenticating over HTTPS — typically the machine's
+        // configured credential helper (e.g. git-credential-osxkeychain) is not on
+        // the app's PATH (GUI-launch PATH divergence: the sidecar inherits launchd's
+        // PATH, not the user's login shell). Retry borrowing gh's credentials — the
+        // SAME auth we use for `gh pr create` below, so if the PR can be created the
+        // push can succeed — instead of depending on a machine credential helper.
+        // `-c credential.helper=` first RESETS the (broken) inherited helper list,
+        // then adds gh's. Harmless for SSH remotes (git ignores credential.helper).
+        // The semantic push (refspec/remote) is unchanged, so the guardrail asserted
+        // above still holds; no-op when gh is absent (retry fails the same way).
+        const retry = await exec.run('git', ['-c', 'credential.helper=', '-c', 'credential.helper=!gh auth git-credential', ...pushArgs], repoDir);
+        if (retry.code === 0)
+            push = retry;
+    }
     if (push.code !== 0) {
         return { state: 'local-only', branch, reason: reasonFrom(push) };
     }
@@ -66,3 +89,18 @@ function reasonFrom(r) {
     const msg = (r.stderr.trim() || r.stdout.trim()).split('\n')[0];
     return msg || `exit ${r.code}`;
 }
+/**
+ * True when a failed `git push` looks like an HTTPS credential/authentication
+ * problem (as opposed to a rejected ref, missing remote, network, etc.) — the
+ * only class worth retrying through gh's credential helper. Matches the
+ * canonical git strings, including the "'credential-<helper>' is not a git
+ * command" case that happens when the configured helper binary isn't on PATH.
+ */
+function isCredentialFailure(r) {
+    const s = `${r.stderr}\n${r.stdout}`.toLowerCase();
+    return (s.includes('could not read username') ||
+        s.includes('could not read password') ||
+        s.includes('authentication failed') ||
+        s.includes('credential-') ||
+        s.includes('terminal prompts disabled'));
+}

package/server/dist/rail-isolated-launch.js

@@ -211,6 +211,17 @@ async function launchIsolatedRail(input, io = {}) {
     let integration;
     const allocated = [];
     await (0, repo_lock_1.withRepoLock)(baseRepo, async () => {
+        // Bring the repo's remote-tracking refs up to date BEFORE resolving the
+        // integration branch or allocating any worktree — otherwise `git worktree
+        // add -b <branch> <path> <bare-name>` resolves against whatever (possibly
+        // stale) commit the user's LOCAL branch happens to be at. `fetchOrigin` only
+        // ever touches `refs/remotes/origin/*`; it never mutates the checked-out
+        // branch/working tree. De-duped per repo for a short TTL so a "Launch all"
+        // batch (N independent launch requests for the same repo, serialized by
+        // this same withRepoLock) performs one real fetch, not one per rail. A
+        // failed fetch (no network / no remote / auth error) never blocks the
+        // launch — resolveWorktreeBaseRef below degrades to the local ref.
+        const fetchResult = await (0, integration_branch_1.fetchOrigin)(git, baseRepo);
         // Resolve the project's designated integration branch ONCE, and branch every
         // ticket's worktree off it (not the ambient HEAD). Empty setting → auto-resolve
         // (repo default → HEAD fallback). See server/integration-branch.ts.
@@ -218,6 +229,20 @@ async function launchIsolatedRail(input, io = {}) {
             repoDir: baseRepo,
             projectSetting: (0, db_1.getProjectSettings)(ctx.db).integrationBranch,
         });
+        // Prefer the freshly-fetched remote-tracking ref (origin/<branch>) over the
+        // bare local name for repo-default/project-setting sources — see
+        // resolveWorktreeBaseRef for the exact fallback policy. `explicit` is left
+        // completely untouched (rare, launch-time-chosen override).
+        const worktreeBaseRef = await (0, integration_branch_1.resolveWorktreeBaseRef)(git, {
+            repoDir: baseRepo, integration, fetchOk: fetchResult.ok,
+        });
+        if (worktreeBaseRef.warning) {
+            console.warn(`[rail-isolated] ${worktreeBaseRef.warning} (repo ${baseRepo})`);
+            try {
+                ctx.broadcast({ type: 'rail.fetch_degraded', projectId: ctx.project.id, railIndex, warning: worktreeBaseRef.warning });
+            }
+            catch { /* non-fatal, mirrors notifyOverlayDegraded's broadcast guard below */ }
+        }
         if (prMode) {
             prDeliveryId = (0, rail_pr_store_1.createPrDelivery)(ctx.db, {
                 railIndex,
@@ -251,7 +276,7 @@ async function launchIsolatedRail(input, io = {}) {
         };
         try {
             for (const unit of units) {
-                const handle = await create(git, { repoDir: baseRepo, worktreesRoot, slug, ticketId: unit.ticketId, baseRef: integration.branch, branch: unitBranchName(unit.ticketId) });
+                const handle = await create(git, { repoDir: baseRepo, worktreesRoot, slug, ticketId: unit.ticketId, baseRef: worktreeBaseRef.baseRef, branch: unitBranchName(unit.ticketId) });
                 // Per-run overlay: merge-link the framework surface the checkout didn't
                 // bring into the worktree (idempotent; resume-safe via its manifest).
                 let overlayExcludes = [];

package/server/dist/vitest-setup.js

@@ -23,3 +23,31 @@ const path_1 = __importDefault(require("path"));
 if (!process.env.SPECRAILS_REGISTRY_HOME) {
     process.env.SPECRAILS_REGISTRY_HOME = (0, fs_1.mkdtempSync)(path_1.default.join(os_1.default.tmpdir(), 'specrails-desktop-test-home-'));
 }
+/**
+ * Hermetic env: a test run must NEVER inherit relocation / desktop-mode env
+ * vars from the host process. When the suite runs INSIDE a Specrails rail spawn
+ * (e.g. a `/specrails:implement` job running the verification step), that parent
+ * process exports `SPECRAILS_REPO_DIR` etc., which leak straight through the
+ * legacy (non-relocated) spawn path — the managers spread `process.env` into the
+ * child env — and break the "LEGACY: no relocation env" assertions in
+ * chat-manager / queue-manager tests. No test relies on ambient inheritance: the
+ * relocated-branch tests activate relocation via the registry + populated
+ * workspace gate, and the path-resolver / setup-prerequisites tests set their
+ * own vars per-case in `beforeEach` (which run AFTER this file), so a
+ * blanket-delete here is safe and any per-case setter still wins. Only
+ * `SPECRAILS_REPO_DIR` breaks a test today; the rest are defense-in-depth (they
+ * would leak identically the moment a future test asserts on them). Do NOT
+ * delete `SPECRAILS_REGISTRY_HOME` — the block above sets it intentionally.
+ */
+for (const k of [
+    'SPECRAILS_REPO_DIR',
+    'SPECRAILS_IS_DESKTOP',
+    'SPECRAILS_BUNDLED_RUNTIMES_PATH',
+    'SPECRAILS_TICKETS_PATH',
+    'SPECRAILS_BACKLOG_CONFIG_PATH',
+    'SPECRAILS_WORKSPACE_DIR',
+    'SPECRAILS_PROFILES_DIR',
+    'SPECRAILS_STATE_DIR',
+]) {
+    delete process.env[k];
+}

package/server/dist/worktree-manager.js

@@ -59,10 +59,14 @@ exports.listWorktrees = listWorktrees;
  */
 const child_process_1 = require("child_process");
 const path = __importStar(require("path"));
+const win_spawn_1 = require("./util/win-spawn");
 exports.defaultGitRunner = {
     run(args, cwd) {
         return new Promise((resolve) => {
-            (0, child_process_1.execFile)('git', args, { cwd, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => {
+            // SystemRoot/ComSpec backfill so worktree + PR-decision git ops don't fail
+            // to start under a pkg-stripped Windows sidecar env. No-op on POSIX.
+            const env = (0, win_spawn_1.windowsSpawnEnv)();
+            (0, child_process_1.execFile)('git', args, { cwd, env, maxBuffer: 16 * 1024 * 1024, windowsHide: true }, (err, stdout, stderr) => {
                 const code = err && typeof err.code === 'number' ? err.code : err ? 1 : 0;
                 resolve({ code, stdout: stdout?.toString() ?? '', stderr: stderr?.toString() ?? '' });
             });