@cursor/july 0.1.62 → 0.1.73

package/dist/internal/terminal-style.js

@@ -4,6 +4,11 @@
  */
 import { clearScreenDown, cursorTo } from "node:readline";
 const IDENTITY = (s) => s;
+const ESC = "\u001b";
+const BEL = "\u0007";
+const ANSI_CSI = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
+/** OSC 8 hyperlinks: `ESC ] 8 ; params ; uri BEL` (or ST). */
+const OSC_8 = new RegExp(`${ESC}\\]8;[^${BEL}${ESC}]*(?:${BEL}|${ESC}\\\\)`, "g");
 const PLAIN = {
     dim: IDENTITY,
     bold: IDENTITY,
@@ -22,7 +27,7 @@ export function makePalette(enabled) {
     }
     const wrap = (code) => (s) => `\u001b[${code}m${s}\u001b[0m`;
     return {
-        dim: wrap("2"),
+        dim: (s) => (hasAnsiStyling(s) ? s : wrap("2")(s)),
         bold: wrap("1"),
         cyan: wrap("36"),
         green: wrap("32"),
@@ -39,6 +44,46 @@ export function stdoutPalette() {
 export function stderrPalette() {
     return makePalette(colorEnabledFor(process.stderr));
 }
+/** Visible column count, ignoring CSI color/style and OSC 8 hyperlinks. */
+export function visibleWidth(text) {
+    return text.replace(OSC_8, "").replace(ANSI_CSI, "").length;
+}
+/** True when `text` already carries CSI styling or OSC 8 (do not wrap again). */
+export function hasAnsiStyling(text) {
+    return text.includes("\u001b[") || text.includes("\u001b]");
+}
+/**
+ * Clickable terminal hyperlink (OSC 8). The URI is the click target; `label`
+ * is what the user sees. `visibleWidth` ignores the OSC wrapper.
+ */
+export function terminalHyperlink(url, label, enabled = colorEnabledFor()) {
+    if (!enabled) {
+        return label;
+    }
+    return `\u001b]8;;${url}\u0007\u001b[4m${label}\u001b[24m\u001b]8;;\u0007`;
+}
+/**
+ * Unicode box around `lines`. `color` wraps the whole box (borders + body)
+ * so a warning panel can be yellow without per-line prefixes.
+ */
+export function formatTerminalBox(lines, options) {
+    var _a, _b, _c;
+    const color = (_a = options === null || options === void 0 ? void 0 : options.color) !== null && _a !== void 0 ? _a : IDENTITY;
+    const padding = (_b = options === null || options === void 0 ? void 0 : options.padding) !== null && _b !== void 0 ? _b : 1;
+    const contentWidth = Math.max((_c = options === null || options === void 0 ? void 0 : options.minWidth) !== null && _c !== void 0 ? _c : 0, ...lines.map((line) => visibleWidth(line)), 1);
+    const inner = contentWidth + padding * 2;
+    const padLine = (line) => {
+        const extra = contentWidth - visibleWidth(line);
+        return `│${" ".repeat(padding)}${line}${" ".repeat(padding + extra)}│`;
+    };
+    const paint = (line) => color(line);
+    const box = [
+        paint(`╭${"─".repeat(inner)}╮`),
+        ...lines.map((line) => paint(padLine(line))),
+        paint(`╰${"─".repeat(inner)}╯`),
+    ].join("\n");
+    return box;
+}
 /** Wipe the terminal before a `dev` Enter-to-restart cycle. */
 export function clearTerminal(stream = process.stdout) {
     if (stream.isTTY !== true) {

package/dist/internal/turn-lease-store.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Durable per-session turn ownership: `activeTurns` is in-memory, so servers
+ * sharing a state root would otherwise both run the same session.
+ *
+ * Exclusion, staleness and liveness refresh come from `proper-lockfile`, which
+ * the monorepo already uses for the git cache. Hand-rolling them means
+ * inferring that a process died — timeouts, heartbeats, and a takeover path
+ * that has to stay atomic while removing another owner's claim. That is where
+ * the subtle races live, and none of it is specific to turns.
+ *
+ * Liveness is lock age, not pid: containers have separate PID namespaces.
+ */
+/** A held turn lease. Releasing is idempotent. */
+export interface TurnLease {
+    release(): Promise<void>;
+}
+export declare class TurnLeaseStore {
+    private readonly dir;
+    private readonly staleMs;
+    /** Locks this process holds. Their release closures cannot live on disk. */
+    private readonly held;
+    constructor(dir: string, options?: {
+        ttlMs?: number;
+    });
+    private path;
+    /**
+     * Undefined when another process holds this session and is still refreshing.
+     *
+     * `onCompromised` fires when the lock is lost mid-turn — the owner stalled
+     * past the stale window and a successor took over. No lease scheme can stop
+     * that; the callback is how the displaced turn learns to stand down instead
+     * of answering alongside its successor.
+     */
+    acquire(sessionId: string, onCompromised?: () => void): Promise<TurnLease | undefined>;
+    private handle;
+    /** Graceful shutdown: drop every claim so a successor need not wait it out. */
+    releaseAll(): Promise<void>;
+    /**
+     * The session is running in another server process. Mirrors the engine's
+     * in-memory `isTurnRunning`, which only ever sees this process.
+     */
+    runningElsewhere(sessionId: string): Promise<boolean>;
+}
+//# sourceMappingURL=turn-lease-store.d.ts.map

package/dist/internal/turn-lease-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-lease-store.d.ts","sourceRoot":"","sources":["../../src/internal/turn-lease-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAMH,kDAAkD;AAClD,MAAM,WAAW,SAAS;IACxB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAmBD,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA+B;IAEpD,YAAY,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAO,EAIxD;IAED,OAAO,CAAC,IAAI;IAIZ;;;;;;;OAOG;IACG,OAAO,CACX,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,IAAI,GACzB,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CA6BhC;IAED,OAAO,CAAC,MAAM;IAwBd,+EAA+E;IACzE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAKhC;IAED;;;OAGG;IACG,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAY1D;CACF"}

package/dist/internal/turn-lease-store.js

@@ -0,0 +1,139 @@
+/**
+ * Durable per-session turn ownership: `activeTurns` is in-memory, so servers
+ * sharing a state root would otherwise both run the same session.
+ *
+ * Exclusion, staleness and liveness refresh come from `proper-lockfile`, which
+ * the monorepo already uses for the git cache. Hand-rolling them means
+ * inferring that a process died — timeouts, heartbeats, and a takeover path
+ * that has to stay atomic while removing another owner's claim. That is where
+ * the subtle races live, and none of it is specific to turns.
+ *
+ * Liveness is lock age, not pid: containers have separate PID namespaces.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import * as lockfile from "proper-lockfile";
+/** Reject path traversal; session ids are opaque strings from the caller. */
+function safeKey(sessionId) {
+    const sanitized = sessionId
+        .trim()
+        .replace(/[^a-zA-Z0-9._-]+/g, "_")
+        .replace(/^\.+/, "")
+        .replace(/\.+/g, "_")
+        .slice(0, 180);
+    return sanitized === "" ? "_empty" : sanitized;
+}
+export class TurnLeaseStore {
+    constructor(dir, options = {}) {
+        var _a;
+        /** Locks this process holds. Their release closures cannot live on disk. */
+        this.held = new Map();
+        this.dir = dir;
+        // Several refreshes, so a slow owner is not mistaken for a dead one.
+        this.staleMs = (_a = options.ttlMs) !== null && _a !== void 0 ? _a : 30000;
+    }
+    path(sessionId) {
+        return join(this.dir, `${safeKey(sessionId)}.lease`);
+    }
+    /**
+     * Undefined when another process holds this session and is still refreshing.
+     *
+     * `onCompromised` fires when the lock is lost mid-turn — the owner stalled
+     * past the stale window and a successor took over. No lease scheme can stop
+     * that; the callback is how the displaced turn learns to stand down instead
+     * of answering alongside its successor.
+     */
+    acquire(sessionId, onCompromised) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existing = this.held.get(sessionId);
+            if (existing !== undefined) {
+                existing.refs += 1;
+                return this.handle(sessionId);
+            }
+            yield mkdir(this.dir, { recursive: true });
+            let release;
+            try {
+                release = yield lockfile.lock(this.path(sessionId), {
+                    realpath: false,
+                    retries: 0,
+                    stale: this.staleMs,
+                    // How often the library refreshes the lock's mtime while we hold it.
+                    update: 5000,
+                    onCompromised: () => {
+                        this.held.delete(sessionId);
+                        onCompromised === null || onCompromised === void 0 ? void 0 : onCompromised();
+                    },
+                });
+            }
+            catch (_a) {
+                // Held elsewhere, or the store is unusable. Either way this process must
+                // not run the turn: coalescing costs latency, two servers on one session
+                // costs the conversation.
+                return undefined;
+            }
+            this.held.set(sessionId, { release, refs: 1 });
+            return this.handle(sessionId);
+        });
+    }
+    handle(sessionId) {
+        let released = false;
+        return {
+            release: () => __awaiter(this, void 0, void 0, function* () {
+                if (released) {
+                    return;
+                }
+                released = true;
+                const lock = this.held.get(sessionId);
+                if (lock === undefined) {
+                    return;
+                }
+                lock.refs -= 1;
+                if (lock.refs > 0) {
+                    return;
+                }
+                this.held.delete(sessionId);
+                // Throws if the lock was already compromised, which is not our problem
+                // to solve here: the successor owns it.
+                yield lock.release().catch(() => { });
+            }),
+        };
+    }
+    /** Graceful shutdown: drop every claim so a successor need not wait it out. */
+    releaseAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [sessionId, lock] of [...this.held]) {
+                this.held.delete(sessionId);
+                yield lock.release().catch(() => { });
+            }
+        });
+    }
+    /**
+     * The session is running in another server process. Mirrors the engine's
+     * in-memory `isTurnRunning`, which only ever sees this process.
+     */
+    runningElsewhere(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.held.has(sessionId)) {
+                return false;
+            }
+            try {
+                return yield lockfile.check(this.path(sessionId), {
+                    realpath: false,
+                    stale: this.staleMs,
+                });
+            }
+            catch (_a) {
+                return false;
+            }
+        });
+    }
+}

package/dist/internal/workspace.d.ts

@@ -99,6 +99,20 @@ export declare function buildAgentsMdContent(agent: ResolvedAgent, options: {
  * are skipped by nested rule discovery.
  */
 export declare function isNestedInGitRepo(dir: string): Promise<boolean>;
+/** Default harness parent for a nested-git agent project. */
+export declare function defaultLocalHarnessCwd(dirName: string): string;
+/**
+ * Give a session workspace its own git root so the harness roots *there*
+ * rather than at the enclosing repo (see {@link isNestedInGitRepo}). Without
+ * it the harness reads the outer repo's `.cursor/hooks.json`, rules, skills
+ * and `mcp.json`, and never sees the ones written into this workspace —
+ * instructions have an inline fallback, hooks have none.
+ *
+ * Best effort: a workspace that already has `.git` (a borrowed checkout or
+ * worktree) is left alone, and a failed `git init` leaves the harness where
+ * it already was.
+ */
+export declare function ensureOwnGitRoot(dir: string): Promise<boolean>;
 export declare function materializeWorkspace(options: MaterializeWorkspaceOptions): Promise<void>;
 /**
  * Generate the SKILL.md the harness reads: `name` + `description`

package/dist/internal/workspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/internal/workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAgBH,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,aAAa,EACd,MAAM,aAAa,CAAC;AAIrB,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,aAAa,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,IAAI,EAAE,OAAO,CAAC;IACd;;;;;;;OAOG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAOjE;AAED,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,mBAAmB,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM1D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,MAAM,GAAG,SAAS,CAapB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,GAAE;IAAE,cAAc,EAAE,OAAO,CAAA;CAA8B,GAC/D,MAAM,CA8CR;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GACjC,MAAM,CA6BR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE;IAAE,cAAc,EAAE,OAAO,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAE,GAChE,MAAM,CAeR;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAcrE;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,IAAI,CAAC,CAkCf;AAqGD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAO3D;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,CACX,MAAM,EACN,MAAM,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CACjE,GACA,OAAO,CAAC,IAAI,CAAC,CAcf"}
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/internal/workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAmBH,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,aAAa,EACd,MAAM,aAAa,CAAC;AAMrB,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,aAAa,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,IAAI,EAAE,OAAO,CAAC;IACd;;;;;;;OAOG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAOjE;AAED,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED;;;;;GAKG;AACH,eAAO,MAAM,4BAA4B,mBAAmB,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM1D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,MAAM,GAAG,SAAS,CAapB;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,GAAE;IAAE,cAAc,EAAE,OAAO,CAAA;CAA8B,GAC/D,MAAM,CA8CR;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,cAAc,EAAE,EACvB,OAAO,EAAE;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,GACjC,MAAM,CA6BR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,aAAa,EACpB,OAAO,EAAE;IAAE,cAAc,EAAE,OAAO,CAAC;IAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAAE,GAChE,MAAM,CAeR;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAcrE;AAED,6DAA6D;AAC7D,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAUpE;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,IAAI,CAAC,CAkCf;AAqGD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAO3D;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,CACX,MAAM,EACN,MAAM,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CACjE,GACA,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/dist/internal/workspace.js

@@ -15,12 +15,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { execFile } from "node:child_process";
 import { chmod, copyFile, lstat, mkdir, readlink, rm, stat, symlink, writeFile, } from "node:fs/promises";
+import { homedir } from "node:os";
 import { dirname, join, parse, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
 import { agentStoreKeys, DEPLOYMENT_STORE_MOUNT_PATH } from "../files.js";
 import { MEMORY_DIR_NAME } from "../memory.js";
 import { parseFrontmatter, serializeFrontmatter } from "./frontmatter.js";
 import { buildIdentitySection } from "./prompt-context.js";
+const execFileAsync = promisify(execFile);
 /**
  * First-turn preamble section for cloud-runtime sessions on hosted
  * deployments: cloud VMs read the memory journal from the store mount.
@@ -219,6 +223,35 @@ export function isNestedInGitRepo(dir) {
         return false;
     });
 }
+/** Default harness parent for a nested-git agent project. */
+export function defaultLocalHarnessCwd(dirName) {
+    return join(homedir(), ".cache", "agent-serve", dirName);
+}
+/**
+ * Give a session workspace its own git root so the harness roots *there*
+ * rather than at the enclosing repo (see {@link isNestedInGitRepo}). Without
+ * it the harness reads the outer repo's `.cursor/hooks.json`, rules, skills
+ * and `mcp.json`, and never sees the ones written into this workspace —
+ * instructions have an inline fallback, hooks have none.
+ *
+ * Best effort: a workspace that already has `.git` (a borrowed checkout or
+ * worktree) is left alone, and a failed `git init` leaves the harness where
+ * it already was.
+ */
+export function ensureOwnGitRoot(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield isNestedInGitRepo(dir))) {
+            return false;
+        }
+        try {
+            yield execFileAsync("git", ["init", "--quiet"], { cwd: dir });
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    });
+}
 export function materializeWorkspace(options) {
     return __awaiter(this, void 0, void 0, function* () {
         const { agent, workspaceDir, seed, stateRoot } = options;