specrails-desktop 2.59.0 → 2.59.1

package/server/dist/worktree-manager.js

@@ -210,7 +210,22 @@ async function createWorktree(git, input) {
     //     it out into a worktree (resume from the committed partial work).
     //  3. neither → create a fresh branch off base.
     const existing = await listWorktrees(git, input.repoDir);
-    if (existing.some((p) => canonicalWorktreePath(p) === canonicalWorktreePath(wt))) {
+    let mounted = existing.find((p) => canonicalWorktreePath(p) === canonicalWorktreePath(wt));
+    if (input.reuseBranchWorktree) {
+        // New allocations have run-specific paths. A continuation must find the
+        // exact recorded branch, never borrow a ticket-keyed mount on another ref.
+        mounted = undefined;
+        for (const candidate of existing) {
+            const head = await git.run(['rev-parse', '--abbrev-ref', 'HEAD'], candidate);
+            if (head.code === 0 && head.stdout.trim() === branch) {
+                mounted = candidate;
+                break;
+            }
+        }
+    }
+    if (mounted) {
+        if (input.fresh)
+            throw new Error(`Fresh launch cannot reuse existing worktree ${mounted}`);
         // The still-mounted worktree may be checked out on a DIFFERENT branch than
         // the caller's preferred name (the path is keyed by ticketId only, so a
         // stale mount from a prior run of the same ticket collides here). The
@@ -218,16 +233,18 @@ async function createWorktree(git, input) {
         // — reporting the caller's preferred name recorded a branch that never
         // existed, so the later `git push` had no ref and the PR delivery wedged
         // at local-only. Detached HEAD / a git failure falls back to the input.
-        const head = await git.run(['rev-parse', '--abbrev-ref', 'HEAD'], wt);
+        const head = await git.run(['rev-parse', '--abbrev-ref', 'HEAD'], mounted);
         const actual = head.code === 0 ? head.stdout.trim() : '';
         const actualBranch = actual && actual !== 'HEAD' ? actual : branch;
         if (input.refreshFromBaseRef && actualBranch === branch) {
-            await fastForwardExistingBranch(git, input.repoDir, branch, input.baseRef, wt);
+            await fastForwardExistingBranch(git, input.repoDir, branch, input.baseRef, mounted);
         }
-        await ensurePrNeverStageExcludes(git, wt);
-        return { branch: actualBranch, worktreePath: wt, worktreeCreated: false, branchCreated: false };
+        await ensurePrNeverStageExcludes(git, mounted);
+        return { branch: actualBranch, worktreePath: mounted, worktreeCreated: false, branchCreated: false };
     }
     const hasBranch = (await git.run(['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`], input.repoDir)).code === 0;
+    if (hasBranch && input.fresh)
+        throw new Error(`Fresh launch cannot reuse existing branch ${branch}`);
     if (hasBranch && input.refreshFromBaseRef) {
         await fastForwardExistingBranch(git, input.repoDir, branch, input.baseRef);
     }
@@ -322,8 +339,94 @@ async function auditStagedPaths(git, worktreePath, excludePaths, phase) {
     const parsed = parseNulTerminatedPaths(result, phase);
     if (parsed.error)
         return { forbidden: [], error: parsed.error };
+    try {
+        const deliverable = parsed.paths.filter(candidate => !forbiddenStagedPaths([candidate], excludePaths).length);
+        const external = deliverable.filter(candidate => {
+            const target = path.join(worktreePath, candidate);
+            let stat;
+            try {
+                stat = fs.lstatSync(target);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT')
+                    return false; // staged deletion
+                throw err;
+            }
+            if (!stat.isSymbolicLink())
+                return false;
+            const link = fs.readlinkSync(target);
+            const relative = path.relative(worktreePath, link);
+            return path.isAbsolute(link) && (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative));
+        });
+        if (external.length)
+            return { forbidden: [], error: `External absolute symlinks cannot be delivered: ${describeForbiddenPaths(external)}. Working files were preserved.` };
+    }
+    catch (err) {
+        return { forbidden: [], error: `Could not inspect staged symlinks: ${err instanceof Error ? err.message : String(err)}` };
+    }
     return { forbidden: forbiddenStagedPaths(parsed.paths, excludePaths) };
 }
+/** Automated delivery must not publish an unfinished change introduced by this
+ * checkout. Baseline active changes and archived changes remain legitimate. */
+async function deliveryHygieneError(git, worktreePath, baseRef) {
+    // Agents may create their own commits before settlement. Index-only checks
+    // cannot catch an overlay link already in HEAD, even when it is now excluded.
+    const changed = parseNulTerminatedPaths(await gitRun(git, ['diff', '--name-only', '--no-renames', '-z', baseRef, 'HEAD', '--'], worktreePath), 'Committed delivery audit');
+    if (changed.error)
+        return changed.error;
+    if (changed.paths.length) {
+        const tree = parseNulTerminatedPaths(await gitRun(git, ['ls-tree', '-r', '-z', 'HEAD'], worktreePath), 'Committed symlink audit');
+        if (tree.error)
+            return tree.error;
+        const paths = new Set(changed.paths);
+        for (const entry of tree.paths) {
+            const tab = entry.indexOf('\t'), metadata = entry.slice(0, tab).split(' '), rel = entry.slice(tab + 1);
+            if (metadata[0] !== '120000' || !paths.has(rel))
+                continue;
+            if (tab < 0 || metadata[1] !== 'blob' || !/^[a-f0-9]{40,64}$/i.test(metadata[2]))
+                return 'Committed symlink audit returned malformed tree evidence';
+            const blob = await gitRun(git, ['cat-file', 'blob', metadata[2]], worktreePath);
+            if (blob.code !== 0)
+                return `Could not inspect committed symlink ${JSON.stringify(rel)}`;
+            const relative = path.relative(worktreePath, blob.stdout);
+            if (path.isAbsolute(blob.stdout) && (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative))) {
+                return `External absolute symlink already committed on the delivery branch: ${JSON.stringify(rel)}. Review and remove it before delivery; working files were preserved.`;
+            }
+        }
+    }
+    const baseline = await gitRun(git, ['ls-tree', '-d', '--name-only', '-z', `${baseRef}:openspec/changes`], worktreePath);
+    // A missing subtree is normal, but an invalid baseline is never a pass.
+    if (baseline.code !== 0) {
+        const exists = await gitRun(git, ['rev-parse', '--verify', `${baseRef}^{commit}`], worktreePath);
+        if (exists.code !== 0)
+            return `Could not inspect OpenSpec delivery baseline: ${gitFailure(exists, baseRef)}`;
+        const root = await gitRun(git, ['ls-tree', '-r', '--name-only', '-z', baseRef, '--', 'openspec/changes'], worktreePath);
+        if (root.code !== 0 || root.stdout)
+            return `Could not inspect OpenSpec delivery baseline: ${gitFailure(baseline, baseRef)}`;
+    }
+    const parsed = baseline.code === 0 ? parseNulTerminatedPaths(baseline, 'OpenSpec baseline audit') : { paths: [] };
+    if (parsed.error)
+        return parsed.error;
+    const known = new Set(parsed.paths);
+    try {
+        const directory = path.join(worktreePath, 'openspec', 'changes');
+        let entries;
+        try {
+            entries = fs.readdirSync(directory, { withFileTypes: true });
+        }
+        catch (err) {
+            if (err.code === 'ENOENT')
+                return undefined;
+            throw err;
+        }
+        const active = entries.filter(entry => entry.name !== 'archive' && (entry.isDirectory() || entry.isSymbolicLink()) && !known.has(entry.name)).map(entry => `openspec/changes/${entry.name}`);
+        if (active.length)
+            return `OpenSpec delivery blocked by new active changes: ${describeForbiddenPaths(active)}. Archive the intended change and review unrelated work before delivery; files were preserved.`;
+    }
+    catch (err) {
+        return `Could not inspect active OpenSpec changes: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}
 function forbiddenResetPathspecs(excludePaths) {
     return [
         '--',
@@ -341,7 +444,12 @@ function describeForbiddenPaths(paths) {
  * agent paths may stay untracked in the worktree because they must never land on
  * the ticket branch or PR.
  */
-async function commitWorktreeAndVerify(git, worktreePath, message, excludePaths = []) {
+async function commitWorktreeAndVerify(git, worktreePath, message, excludePaths = [], baseRef) {
+    if (baseRef) {
+        const error = await deliveryHygieneError(git, worktreePath, baseRef);
+        if (error)
+            return { staged: false, committed: false, clean: false, dirty: [], error };
+    }
     const pathspecs = commitPathspecs(excludePaths);
     // The add is deliberately PLAIN — no exclude pathspecs. `git add` exits 1
     // with "The following paths are ignored by one of your .gitignore files"

package/server/dist/worktree-overlay.js

@@ -137,11 +137,11 @@ function overlayRootsOf(input) {
  *  manifest entry may authenticate against. Empty for unauthorised rels. */
 function sourceCandidatesForOverlayEntry(input, rel) {
     const roots = overlayRootsOf(input);
-    if (rel === '.mcp.json' || rel === input.instructionsFilename) {
+    if (rel === '.mcp.json' || [input.instructionsFilename, 'CLAUDE.md', 'AGENTS.md', 'GEMINI.md'].includes(rel)) {
         return roots.map((root) => path_1.default.join(root, rel));
     }
-    const providerPrefix = `${input.providerDir}/`;
-    if (!rel.startsWith(providerPrefix))
+    const providerPrefix = [input.providerDir, '.claude', '.codex', '.gemini', '.kimi-code'].map(dir => `${dir}/`).find(prefix => rel.startsWith(prefix));
+    if (!providerPrefix)
         return [];
     const providerRel = rel.slice(providerPrefix.length);
     if (!providerRel || providerRel === 'worktrees' || providerRel.startsWith('worktrees/'))
@@ -247,7 +247,7 @@ function captureOverlayCleanupEvidence(input, candidates, includeManifest = fals
                 if (dereferencedDigest(source) === destinationDigest)
                     return true;
                 // A bootstrap refresh is still an exact, reproducible source copy.
-                if (rel !== input.instructionsFilename || !destinationStat.isFile())
+                if (![input.instructionsFilename, 'CLAUDE.md', 'AGENTS.md', 'GEMINI.md', '.kimi-code/AGENTS.md'].includes(rel) || !destinationStat.isFile())
                     return false;
                 try {
                     return fs_1.default.readFileSync(destination, 'utf8') === refreshLegacyInstructions(fs_1.default.readFileSync(source, 'utf8'));

package/client/dist/assets/RepositoryScopeSelector-DKzvIGSZ.js

@@ -1,2 +0,0 @@
-import{t as e}from"./jsx-runtime-zu2_FqZY.js";import{n as t}from"./createLucideIcon-Bjbbp_KS.js";import{r as n}from"./useDesktop-D07TvesS.js";import{t as r}from"./project-repositories-DXhb9FP4.js";var i=e();function a({value:e,onChange:a,disabled:o=!1,repositories:s,workspaceOnly:c=!1,workspaceSelection:l,onWorkspaceChange:u}){let{t:d}=t(`common`),{activeProjectId:f,projects:p}=n(),m=s??r(p.find(e=>e.id===f)),h=m.find(e=>e.isPrimary),g=e??(h?[h.id]:[]),_=g.some(e=>!m.some(t=>t.id===e));if(c){let e=m.filter(e=>g.includes(e.id)&&(e.workspacePaths?.length||e.workspacePath));return e.length?(0,i.jsxs)(`fieldset`,{className:`space-y-2`,disabled:o,children:[(0,i.jsx)(`legend`,{className:`text-xs font-medium`,children:d(`repositories.launchWorkspaces`)}),(0,i.jsx)(`p`,{className:`text-xs text-muted-foreground`,children:d(`repositories.launchWorkspaceHint`)}),e.map(e=>{let t=e.workspacePaths??[e.workspacePath],n=l?.[e.id]??t;return(0,i.jsxs)(`div`,{className:`space-y-1`,children:[(0,i.jsx)(`span`,{className:`text-xs font-medium`,children:e.name}),t.map(t=>(0,i.jsxs)(`label`,{className:`flex items-center gap-2 text-xs`,title:t,children:[(0,i.jsx)(`input`,{type:`checkbox`,checked:n.includes(t),disabled:o||n.length===1&&n[0]===t,onChange:r=>u?.({...Object.fromEntries(Object.entries(l??{}).filter(([e])=>g.includes(e))),[e.id]:r.target.checked?[...n,t]:n.filter(e=>e!==t)})}),(0,i.jsx)(`span`,{className:`break-all`,children:t})]},t))]},e.id)})]}):null}return m.length<=1&&!_?null:(0,i.jsxs)(`fieldset`,{className:`space-y-2`,disabled:o,children:[(0,i.jsx)(`legend`,{className:`mb-1 text-xs font-medium`,children:d(`repositories.specScope`)}),(0,i.jsx)(`p`,{className:`text-xs text-muted-foreground`,children:d(`repositories.scopeHint`)}),(0,i.jsxs)(`div`,{className:`flex flex-wrap gap-2`,children:[m.map(e=>(0,i.jsxs)(`label`,{title:e.workspacePaths?.join(`
-`)??e.workspacePath??e.path,className:`flex items-center gap-2 rounded border border-border px-2 py-1.5 text-xs`,children:[(0,i.jsx)(`input`,{type:`checkbox`,checked:g.includes(e.id),disabled:o||e.kind===`folder`&&!e.isPrimary&&!g.includes(e.id)||g.length===1&&g[0]===e.id,onChange:t=>a(t.target.checked?[...g,e.id]:g.filter(t=>t!==e.id))}),e.name,e.workspacePaths?.map(e=>(0,i.jsx)(`span`,{className:`text-muted-foreground`,children:e},e)),!e.workspacePaths&&e.workspacePath&&(0,i.jsx)(`span`,{className:`text-muted-foreground`,children:e.workspacePath}),e.kind===`folder`&&!e.isPrimary&&(0,i.jsx)(`span`,{className:`text-muted-foreground`,children:d(`repositories.contextOnly`)})]},e.id)),g.filter(e=>!m.some(t=>t.id===e)).map(e=>(0,i.jsxs)(`label`,{className:`flex items-center gap-2 rounded border border-destructive px-2 py-1.5 text-xs`,children:[(0,i.jsx)(`input`,{type:`checkbox`,checked:!0,disabled:o||g.length===1,onChange:()=>a(g.filter(t=>t!==e))}),d(`repositories.unavailable`),`: `,e]},e))]}),_&&(0,i.jsx)(`p`,{role:`alert`,className:`text-xs text-destructive`,children:d(`repositories.invalidSelection`)})]})}export{a as t};