specrails-desktop 2.24.0 → 2.24.2

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

@@ -80,6 +80,8 @@ const feature_flags_1 = require("./feature-flags");
 const file_provenance_1 = require("./file-provenance");
 const file_story_1 = require("./file-story");
 const providers_1 = require("./providers");
+const pr_publisher_1 = require("./pr-publisher");
+const active_pr_continuation_1 = require("./active-pr-continuation");
 /**
  * Ticket data for the conventional branch name (pr-naming): title/labels from
  * the ticket-spec reader, the Jira key resolved with the authoritative
@@ -106,6 +108,18 @@ function unitNamingInput(ctx, ticketId) {
     }
     return { ticketId, title: spec?.title ?? null, labels: spec?.labels ?? null, jiraKey };
 }
+/**
+ * Commit messages are consumed by GitHub↔Jira development panels. Branch names
+ * already carry the Jira key for new work; commits must too, especially when
+ * continuing an existing PR whose branch name may predate the current ticket
+ * key. Keep the local id as a fallback/cross-reference for Specrails.
+ */
+function worktreeCommitMessage(ctx, ticketId, runId, partial = false) {
+    const input = unitNamingInput(ctx, ticketId);
+    const ref = (0, pr_naming_1.ticketRef)(input);
+    const subjectRef = ref === String(ticketId) ? `ticket-${ticketId}` : `${ref} ticket-${ticketId}`;
+    return `specrails: ${subjectRef}${partial ? ' partial' : ''} (run ${runId})`;
+}
 /**
  * Launch the rail's tickets in isolated worktrees + schedule the merge-back.
  * Returns the loop run ids. Throws if worktree allocation fails (the caller then
@@ -115,6 +129,7 @@ function unitNamingInput(ctx, ticketId) {
 async function launchIsolatedRail(input, io = {}) {
     const { ctx, railIndex, ticketIds, loopId, loopName, loopGraph, provider, model, effort } = input;
     const git = io.git ?? worktree_manager_1.defaultGitRunner;
+    const exec = io.exec ?? pr_publisher_1.defaultExec;
     const create = io.create ?? worktree_manager_1.createWorktree;
     const remove = io.remove ?? worktree_manager_1.removeWorktree;
     const overlay = io.overlay ?? worktree_overlay_1.applyWorktreeOverlay;
@@ -209,8 +224,20 @@ async function launchIsolatedRail(input, io = {}) {
     //    Only allocation is locked — the fan-out (the actual AI runs) below
     //    stays fully parallel.
     let integration;
+    let launchContinuation = null;
     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,13 +245,58 @@ 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 */ }
+        }
+        // Active-PR continuation: if a ticket is already parked on_review with a
+        // matching OPEN GitHub PR (or a Jira-linked in_progress ticket explicitly
+        // matches an open PR, covering unmapped Jira "Review" statuses), run the next
+        // pass directly on that PR's head branch. Fresh tickets stay on the normal
+        // integration-base path. Keep this deliberately single-target for now: one
+        // rail delivery row can represent one PR URL, so multi-PR batches continue to
+        // use the existing new-work flow instead of silently mixing PRs.
+        const continuationTargets = await (0, active_pr_continuation_1.resolveActivePrContinuationTargets)({
+            db: ctx.db,
+            git,
+            exec,
+            repoDir: baseRepo,
+            ticketIds: units.map((u) => u.ticketId),
+            integrationBranch: integration.branch,
+            fetchOk: fetchResult.ok,
+            getTicketSpec: (ticketId) => {
+                try {
+                    return ctx.getTicketSpec(ticketId);
+                }
+                catch {
+                    return undefined;
+                }
+            },
+        });
+        const uniqueContinuationKeys = new Set(units
+            .map((u) => continuationTargets.get(u.ticketId))
+            .filter((t) => !!t)
+            .map((t) => `${t.prUrl ?? ''}\n${t.branch}`));
+        if (uniqueContinuationKeys.size === 1 && units.every((u) => continuationTargets.has(u.ticketId))) {
+            launchContinuation = continuationTargets.get(units[0].ticketId) ?? null;
+        }
         if (prMode) {
             prDeliveryId = (0, rail_pr_store_1.createPrDelivery)(ctx.db, {
                 railIndex,
                 loopId,
                 railKey: `${railIndex}-${loopId}`,
                 ticketIds: [...ticketIds],
-                baseBranch: integration.branch,
+                baseBranch: launchContinuation?.baseBranch ?? integration.branch,
                 loopName,
                 originSurface: input.originSurface ?? 'dashboard',
                 originConversationId: input.originConversationId ?? null,
@@ -241,6 +313,11 @@ async function launchIsolatedRail(input, io = {}) {
         // launches see each other's just-created branches.
         const takenBranches = await (0, worktree_manager_1.listLocalBranches)(git, baseRepo);
         const unitBranchName = (ticketId) => {
+            const continuation = launchContinuation && continuationTargets.get(ticketId);
+            if (continuation) {
+                takenBranches.add(continuation.branch);
+                return continuation.branch;
+            }
             const preferred = (0, pr_naming_1.ticketBranchName)(unitNamingInput(ctx, ticketId));
             const branch = (0, pr_naming_1.resolveCollisionFreeName)(preferred, {
                 taken: (name) => takenBranches.has(name) && !(0, rail_worktrees_store_1.railWorktreeBranchExistsForTicket)(ctx.db, ticketId, name),
@@ -251,7 +328,15 @@ 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 continuationTarget = launchContinuation ? continuationTargets.get(unit.ticketId) ?? null : null;
+                const handle = await create(git, {
+                    repoDir: baseRepo,
+                    worktreesRoot,
+                    slug,
+                    ticketId: unit.ticketId,
+                    baseRef: continuationTarget?.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 = [];
@@ -290,7 +375,7 @@ async function launchIsolatedRail(input, io = {}) {
                     id: ledgerId, railIndex, ticketId: unit.ticketId, runId,
                     branch: handle.branch, worktreePath: handle.worktreePath,
                 });
-                allocated.push({ ticketId: unit.ticketId, ticketIds: unit.ticketIds, runId, ledgerId, handle, overlayExcludes, provenanceSnapshot });
+                allocated.push({ ticketId: unit.ticketId, ticketIds: unit.ticketIds, runId, ledgerId, handle, overlayExcludes, provenanceSnapshot, continuationTarget });
             }
         }
         catch (err) {
@@ -354,7 +439,7 @@ async function launchIsolatedRail(input, io = {}) {
             // Commit the run's work to its branch so the merge-back can integrate it
             // (loops like autoloop-tdd don't commit) and a re-launch can resume it.
             // Overlay scaffolding is excluded — it must never reach the branch/PR.
-            await (0, worktree_manager_1.commitWorktree)(git, a.handle.worktreePath, `specrails: ticket-${a.ticketId} (run ${a.runId})`, a.overlayExcludes);
+            await (0, worktree_manager_1.commitWorktree)(git, a.handle.worktreePath, worktreeCommitMessage(ctx, a.ticketId, a.runId), a.overlayExcludes);
             (0, rail_worktrees_store_1.updateRailWorktreeState)(ctx.db, a.ledgerId, succeeded ? 'built' : 'failed');
             return { run: a, succeeded };
         })
@@ -363,7 +448,7 @@ async function launchIsolatedRail(input, io = {}) {
             ctx.onLoopRunFinished(a.runId, 'failed', runFinishedOpts);
             recordRunProvenance(a);
             // Commit partial work too → durable in git → resumable on re-launch.
-            await (0, worktree_manager_1.commitWorktree)(git, a.handle.worktreePath, `specrails: ticket-${a.ticketId} partial (run ${a.runId})`, a.overlayExcludes);
+            await (0, worktree_manager_1.commitWorktree)(git, a.handle.worktreePath, worktreeCommitMessage(ctx, a.ticketId, a.runId, true), a.overlayExcludes);
             (0, rail_worktrees_store_1.updateRailWorktreeState)(ctx.db, a.ledgerId, 'failed');
             return { run: a, succeeded: false };
         });
@@ -402,8 +487,23 @@ async function launchIsolatedRail(input, io = {}) {
             // → auto-close (per-run settle already reverted the tickets).
             const worktreeIds = allocated.map((a) => a.ledgerId);
             const anySucceeded = results.some((r) => r.succeeded);
-            const next = anySucceeded ? 'on_review' : 'discarded';
-            if (prDeliveryId && (0, rail_pr_store_1.transitionDecision)(ctx.db, prDeliveryId, 'building', next, { branches, worktreeIds })) {
+            const settledContinuation = anySucceeded ? launchContinuation : null;
+            const next = anySucceeded
+                ? (settledContinuation
+                    ? (settledContinuation.isDraft === false ? 'pr_ready' : 'pr_draft')
+                    : 'on_review')
+                : 'discarded';
+            const patch = settledContinuation
+                ? {
+                    branches,
+                    worktreeIds,
+                    branch: settledContinuation.branch,
+                    prUrl: settledContinuation.prUrl,
+                    prNumber: settledContinuation.prNumber,
+                    prState: 'pr-created',
+                }
+                : { branches, worktreeIds };
+            if (prDeliveryId && (0, rail_pr_store_1.transitionDecision)(ctx.db, prDeliveryId, 'building', next, patch)) {
                 broadcastPrState();
                 // Completion driver: refresh the origin conversation's card in place —
                 // on_review asks the question, discarded informs the outcome.

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() ?? '' });
             });