specrails-desktop 2.11.8 → 2.11.9

package/package.json

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

package/server/dist/path-resolver.js

@@ -157,6 +157,16 @@ function windowsGlobalBinDirs() {
         dirs.push(path_1.default.join(userProfile, '.local', 'bin'));
         dirs.push(path_1.default.join(userProfile, 'scoop', 'shims'));
     }
+    // Windows system dirs. A GUI-launched / pkg-stripped sidecar can inherit a PATH
+    // missing %SystemRoot%\System32 — which holds `taskkill`/`where`, and \Wbem
+    // holds `wmic`. Without them, cmd.exe-mediated tools fail: `tree-kill`'s
+    // `taskkill` silently no-ops (a cancelled rail keeps running). Existence-gated
+    // by the callers; harmless when already present (the common case).
+    const systemRoot = process.env.SystemRoot || process.env.windir;
+    if (systemRoot) {
+        dirs.push(path_1.default.join(systemRoot, 'System32'));
+        dirs.push(path_1.default.join(systemRoot, 'System32', 'Wbem'));
+    }
     return dirs;
 }
 /**

package/server/dist/project-router-jobs.js

@@ -115,6 +115,11 @@ function registerJobsRoutes(deps) {
                 res.json({ ok: true, status: 'deleted' });
             }
             else {
+                // Surface the real error (name/message/stack) so an unexpected cancel
+                // failure — e.g. a Windows kill throw — is identifiable instead of being
+                // masked as a bare "Internal server error".
+                const e = err;
+                console.error(`[jobs] cancel ${req.params.id} failed: ${e?.name}: ${e?.message}\n${e?.stack ?? ''}`);
                 res.status(500).json({ error: 'Internal server error' });
             }
         }

package/server/dist/queue-manager.js

@@ -10,7 +10,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const readline_1 = require("readline");
 const ids_1 = require("./ids");
-const tree_kill_1 = __importDefault(require("tree-kill"));
+const win_spawn_1 = require("./util/win-spawn");
 const types_1 = require("./types");
 const command_resolver_1 = require("./command-resolver");
 const cli_prompt_1 = require("./util/cli-prompt");
@@ -283,12 +283,12 @@ class QueueManager {
         if (proc && proc.pid) {
             const pid = proc.pid;
             try {
-                (0, tree_kill_1.default)(pid, 'SIGTERM');
+                (0, win_spawn_1.treeKillSafe)(pid, 'SIGTERM', () => { });
             }
             catch { /* best-effort */ }
             const grace = setTimeout(() => {
                 try {
-                    (0, tree_kill_1.default)(pid, 'SIGKILL', () => { });
+                    (0, win_spawn_1.treeKillSafe)(pid, 'SIGKILL', () => { });
                 }
                 catch { /* best-effort */ }
             }, 5000);
@@ -993,6 +993,33 @@ class QueueManager {
         // Build supplementary context (output chaining + headless mode) that goes
         // into --append-system-prompt, keeping the user prompt clean.
         let systemAppend = '';
+        // Repository orientation (relocated projects only). The rail spawns from the
+        // WORKSPACE cwd, which holds only `.specrails/` config — NOT the source code.
+        // The repo is reachable via `--add-dir <repoDir>` (injected below) and the
+        // `./project` link. The framework templates point at `${SPECRAILS_REPO_DIR:-.}`,
+        // but the agent's Read/Grep/Glob/Edit tools do NOT expand that shell-var form
+        // (and PowerShell/cmd.exe don't expand POSIX `${VAR:-default}` either) — so on
+        // Windows the agent reads a bogus literal path, falls back to the empty
+        // workspace cwd, finds only framework files, and hallucinates a wrong/"global"
+        // project. Tell it the concrete absolute repo path explicitly. Mirrors the
+        // Explore-cwd orientation. Legacy (non-relocated) ⇒ cwd IS the repo ⇒ skipped
+        // (byte-identical). The `\${` keeps the shell-var form literal in this string.
+        if (execution.relocated && execution.repoDir) {
+            systemAppend +=
+                `REPOSITORY LOCATION — READ THIS FIRST:\n` +
+                    `This pipeline runs from a workspace directory that contains ONLY specrails ` +
+                    `configuration (.specrails/, agent definitions) — NOT your project's source code. ` +
+                    `Your project's source repository is at this ABSOLUTE path:\n` +
+                    `  ${execution.repoDir}\n` +
+                    `It is also exposed to your tools as an additional working directory (via --add-dir) ` +
+                    `and mounted in this cwd as ./project. Use the absolute repo path above (or ./project) ` +
+                    `for ALL source reads, edits, greps and globs. Your Read/Grep/Glob/Edit tools do NOT ` +
+                    `expand shell variables — NEVER pass a literal "\${SPECRAILS_REPO_DIR:-.}" or ` +
+                    `"\${SPECRAILS_REPO_DIR}" as a path; substitute the absolute path above instead. ` +
+                    `The spec/ticket store (.specrails/local-tickets.json) lives in THIS workspace cwd. ` +
+                    `Do NOT look for source files under this cwd — they exist only under the repository ` +
+                    `path above.\n\n`;
+        }
         // Output chaining: inject previous step's output as context for dependent jobs
         if (job.dependsOnJobId) {
             const parentJob = this._jobs.get(job.dependsOnJobId);
@@ -1788,10 +1815,22 @@ class QueueManager {
             clearTimeout(this._killTimer);
             this._killTimer = null;
         }
-        (0, tree_kill_1.default)(this._activeProcess.pid, 'SIGTERM');
         const pid = this._activeProcess.pid;
+        // treeKillSafe never throws synchronously, but wrap defensively so a kill
+        // failure can NEVER propagate into the cancel HTTP route as a 500. On Windows
+        // it invokes an absolute taskkill (PATH-independent) so the tree is actually
+        // killed; the callback surfaces any failure instead of swallowing it.
+        try {
+            (0, win_spawn_1.treeKillSafe)(pid, 'SIGTERM', (err) => {
+                if (err)
+                    console.error(`[kill] SIGTERM tree-kill failed for pid ${pid}: ${err.message}`);
+            });
+        }
+        catch (err) {
+            console.error(`[kill] SIGTERM tree-kill threw for pid ${pid}: ${err.message}`);
+        }
         this._killTimer = setTimeout(() => {
-            (0, tree_kill_1.default)(pid, 'SIGKILL', (err) => {
+            (0, win_spawn_1.treeKillSafe)(pid, 'SIGKILL', (err) => {
                 if (err) {
                     // SIGKILL failed — force cleanup so queue is not permanently blocked.
                     console.error(`[kill] SIGKILL failed for pid ${pid}: ${err.message}`);

package/server/dist/util/win-spawn.js

@@ -24,6 +24,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.treeKillSafe = treeKillSafe;
 exports.spawnCli = spawnCli;
 exports.windowsSpawnEnv = windowsSpawnEnv;
 exports.stripWindowsVerbatimPrefix = stripWindowsVerbatimPrefix;
@@ -32,6 +33,39 @@ exports.__resetWindowsBinaryResolveCacheForTest = __resetWindowsBinaryResolveCac
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const tree_kill_1 = __importDefault(require("tree-kill"));
+/**
+ * Kill a process tree, robustly on Windows. `tree-kill` shells out to
+ * `exec('taskkill /pid … /T /F')` through cmd.exe, which resolves `taskkill`
+ * against the spawn env's PATH — but `taskkill.exe` lives in
+ * `%SystemRoot%\System32`, which a GUI-launched / pkg-stripped sidecar's PATH can
+ * lack, so the kill silently no-ops (the rail keeps running) and, with no
+ * callback, the failure is swallowed. Here we instead invoke the ABSOLUTE
+ * `taskkill.exe` with a SystemRoot-backfilled env (`windowsSpawnEnv`), so the
+ * kill never depends on PATH. POSIX delegates to `tree-kill` unchanged
+ * (byte-identical). Errors are always surfaced via `callback`.
+ */
+function treeKillSafe(pid, signal, callback) {
+    const done = (err) => { if (callback)
+        callback(err); };
+    if (process.platform !== 'win32') {
+        (0, tree_kill_1.default)(pid, signal, (err) => done(err ?? undefined));
+        return;
+    }
+    /* c8 ignore start -- Windows-only branch; coverage runs on Linux/macOS */
+    try {
+        const env = windowsSpawnEnv();
+        const systemRoot = (env.SystemRoot || env.windir || 'C:\\Windows').replace(/[\\/]$/, '');
+        const taskkill = path_1.default.join(systemRoot, 'System32', 'taskkill.exe');
+        // /T = whole tree, /F = force. taskkill has no SIGTERM/SIGKILL distinction;
+        // `tree-kill` already always force-kills on win32, so behaviour is unchanged.
+        (0, child_process_1.execFile)(taskkill, ['/pid', String(pid), '/T', '/F'], { env }, (err) => done(err ?? undefined));
+    }
+    catch (err) {
+        done(err);
+    }
+    /* c8 ignore stop */
+}
 function spawnCli(binary, args, options = {}) {
     /* c8 ignore next 8 -- Windows-only branch; coverage runs on Linux/macOS */
     if (process.platform === 'win32') {