@nurix/nustack 0.19.0 → 0.19.2

package/dist/lib/records/door.js

@@ -0,0 +1,223 @@
+import { randomUUID } from "node:crypto";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { ensureAccessToken } from "../auth_grant.js";
+import { resolveNuStackUrl } from "../nustack_client.js";
+import { resolveProjectId } from "../project_context.js";
+export const RECORD_KINDS = ["backlog", "backlog.remove", "bookkeeping", "gate_event"];
+export const RECORDS_BATCH_CAP = 200;
+const REQUEST_TIMEOUT_MS = 10_000;
+const RETRY_BASE_MS = 30_000;
+const RETRY_CEILING_MS = 60 * 60 * 1000;
+export function isRecordKind(value) {
+    return typeof value === "string" && RECORD_KINDS.includes(value);
+}
+export function idempotencyKeyOf(project, kind, anchor) {
+    return `${project}:${kind}:${anchor}`;
+}
+async function readMountDoor(root) {
+    const manifest = path.join(root, ".claude", "harness.json");
+    if (!existsSync(manifest))
+        return undefined;
+    try {
+        const parsed = JSON.parse(await readFile(manifest, "utf8"));
+        if (!parsed.mount || !("door" in parsed.mount))
+            return undefined;
+        const door = parsed.mount.door;
+        return typeof door === "string" && door.trim() !== "" ? door.trim().replace(/\/+$/, "") : null;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function resolveDoor(root, globals, projectFlag) {
+    const project = await resolveProjectId(root, projectFlag ? { project: projectFlag } : {});
+    if (!project.ok)
+        return { kind: "store", projectId: null, root, reason: "this folder is not bound to a Project" };
+    const door = await readMountDoor(root);
+    if (door === null)
+        return { kind: "store", projectId: project.projectId, root, reason: "the harness manifest configures no door" };
+    return { kind: "door", projectId: project.projectId, doorUrl: door ?? resolveNuStackUrl(globals), isPlatformDefault: door === undefined, root };
+}
+export class DoorRefusedError extends Error {
+}
+export async function postRecords(doorUrl, projectId, kind, rows) {
+    const auth = await ensureAccessToken(doorUrl).catch(() => null);
+    if (!auth)
+        throw new DoorRefusedError("this device is signed out");
+    let response;
+    try {
+        response = await fetch(`${doorUrl}/api/v2/projects/${encodeURIComponent(projectId)}/records`, {
+            method: "POST",
+            headers: { "content-type": "application/json", authorization: `Bearer ${auth.accessToken}` },
+            body: JSON.stringify({ kind, rows }),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+    }
+    catch (error) {
+        throw new DoorRefusedError(`the door did not answer: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const payload = (await response.json().catch(() => null));
+    if (!response.ok) {
+        const detail = payload?.error?.message ?? `HTTP ${response.status}`;
+        throw new DoorRefusedError(`${payload?.error?.code ?? `HTTP ${response.status}`}: ${detail}`);
+    }
+    return { landed: payload?.data?.landed ?? 0, skipped: payload?.data?.skipped ?? 0 };
+}
+function outboxOf(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        kind: row.kind,
+        idempotencyKey: row.idempotency_key,
+        doorUrl: row.door_url,
+        row: JSON.parse(row.row_json),
+        attempts: row.attempts,
+        nextRetryAtMs: row.next_retry_at_ms ?? null,
+        lastError: row.last_error ?? null,
+        createdAtMs: row.created_at_ms,
+    };
+}
+function storedOf(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id ?? null,
+        repositoryRoot: row.repository_root,
+        kind: row.kind,
+        idempotencyKey: row.idempotency_key,
+        row: JSON.parse(row.row_json),
+        createdAtMs: row.created_at_ms,
+    };
+}
+export function retryDelayMs(attempts) {
+    return Math.min(RETRY_BASE_MS * 2 ** Math.max(0, attempts - 1), RETRY_CEILING_MS);
+}
+export function enqueueOutbox(store, input) {
+    const now = Date.now();
+    const key = idempotencyKeyOf(input.projectId, input.kind, input.row.anchor);
+    store.db
+        .prepare(`INSERT INTO record_outbox (id, project_id, kind, idempotency_key, door_url, row_json, attempts,
+                next_retry_at_ms, last_error, created_at_ms, updated_at_ms)
+             VALUES (:id, :project_id, :kind, :key, :door_url, :row_json, 1, :next_retry_at_ms, :last_error, :now, :now)
+             ON CONFLICT(idempotency_key) DO UPDATE SET
+                row_json = excluded.row_json, door_url = excluded.door_url, attempts = 1,
+                next_retry_at_ms = excluded.next_retry_at_ms, last_error = excluded.last_error,
+                created_at_ms = excluded.created_at_ms, updated_at_ms = excluded.updated_at_ms`)
+        .run({
+        id: randomUUID(),
+        project_id: input.projectId,
+        kind: input.kind,
+        key,
+        door_url: input.doorUrl,
+        row_json: JSON.stringify({ ...input.row, idempotencyKey: key }),
+        next_retry_at_ms: now + retryDelayMs(1),
+        last_error: input.error,
+        now,
+    });
+    return outboxOf(store.db.prepare("SELECT * FROM record_outbox WHERE idempotency_key = ?").get(key));
+}
+export function keepInStore(store, input) {
+    const now = Date.now();
+    const key = idempotencyKeyOf(input.projectId ?? input.root, input.kind, input.row.anchor);
+    store.db
+        .prepare(`INSERT INTO record_store (id, project_id, repository_root, kind, idempotency_key, row_json, created_at_ms, updated_at_ms)
+             VALUES (:id, :project_id, :root, :kind, :key, :row_json, :now, :now)
+             ON CONFLICT(idempotency_key) DO UPDATE SET row_json = excluded.row_json, created_at_ms = excluded.created_at_ms,
+                updated_at_ms = excluded.updated_at_ms`)
+        .run({
+        id: randomUUID(),
+        project_id: input.projectId,
+        root: input.root,
+        kind: input.kind,
+        key,
+        row_json: JSON.stringify({ ...input.row, idempotencyKey: key }),
+        now,
+    });
+    return storedOf(store.db.prepare("SELECT * FROM record_store WHERE idempotency_key = ?").get(key));
+}
+export function listOutbox(store, projectId) {
+    const rows = projectId
+        ? store.db.prepare("SELECT * FROM record_outbox WHERE project_id = ? ORDER BY created_at_ms ASC, rowid ASC").all(projectId)
+        : store.db.prepare("SELECT * FROM record_outbox ORDER BY created_at_ms ASC, rowid ASC").all();
+    return rows.map(outboxOf);
+}
+export function listStored(store, filter = {}) {
+    const rows = store.db.prepare("SELECT * FROM record_store ORDER BY created_at_ms ASC, rowid ASC").all();
+    return rows
+        .map(storedOf)
+        .filter((row) => (!filter.projectId || row.projectId === filter.projectId) && (!filter.root || row.repositoryRoot === filter.root));
+}
+export async function emitRecords(store, resolution, kind, rows) {
+    if (resolution.kind === "store") {
+        const kept = rows.map((row) => keepInStore(store, { projectId: resolution.projectId, root: resolution.root, kind, row }));
+        return { rung: 3, projectId: resolution.projectId, keys: kept.map((row) => row.idempotencyKey), reason: resolution.reason };
+    }
+    const { projectId, doorUrl } = resolution;
+    const parkedDoor = resolution.isPlatformDefault ? "" : doorUrl;
+    const keyed = rows.map((row) => ({ ...row, idempotencyKey: idempotencyKeyOf(projectId, kind, row.anchor) }));
+    const keys = keyed.map((row) => row.idempotencyKey);
+    try {
+        const result = await postRecords(doorUrl, projectId, kind, keyed);
+        return { rung: 1, projectId, keys, ...result };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        for (const row of rows)
+            enqueueOutbox(store, { projectId, kind, doorUrl: parkedDoor, row, error: message });
+        return { rung: 2, projectId, keys, error: message };
+    }
+}
+export async function drainOutbox(store, globals, options = {}) {
+    const now = Date.now();
+    let rows = listOutbox(store);
+    if (options.dueOnly)
+        rows = rows.filter((row) => row.nextRetryAtMs === null || row.nextRetryAtMs <= now);
+    if (options.limit !== undefined)
+        rows = rows.slice(0, options.limit);
+    let sent = 0;
+    let kept = 0;
+    let lastError = null;
+    for (const row of rows) {
+        try {
+            await postRecords(row.doorUrl || resolveNuStackUrl(globals), row.projectId, row.kind, [row.row]);
+            store.db.prepare("DELETE FROM record_outbox WHERE id = ?").run(row.id);
+            sent += 1;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+            store.db
+                .prepare(`UPDATE record_outbox SET attempts = attempts + 1, next_retry_at_ms = ?, last_error = ?, updated_at_ms = ? WHERE id = ?`)
+                .run(Date.now() + retryDelayMs(row.attempts + 1), lastError, Date.now(), row.id);
+            kept += 1;
+        }
+    }
+    return { sent, kept, lastError };
+}
+export async function drainStore(store, globals) {
+    let sent = 0;
+    let kept = 0;
+    let lastError = null;
+    for (const row of listStored(store)) {
+        if (!existsSync(row.repositoryRoot)) {
+            kept += 1;
+            continue;
+        }
+        const door = await resolveDoor(row.repositoryRoot, globals);
+        if (door.kind !== "door") {
+            kept += 1;
+            continue;
+        }
+        const keyed = { ...row.row, idempotencyKey: idempotencyKeyOf(door.projectId, row.kind, row.row.anchor) };
+        try {
+            await postRecords(door.doorUrl, door.projectId, row.kind, [keyed]);
+            store.db.prepare("DELETE FROM record_store WHERE id = ?").run(row.id);
+            sent += 1;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+            kept += 1;
+        }
+    }
+    return { sent, kept, lastError };
+}

package/dist/lib/session-engine/supervisor.js

@@ -7,6 +7,7 @@ import { FRAME_VERSION, parseInboundFrame, serializeFrame, } from "./frames.js";
 import { inspectSession, reclaimSession } from "./prune.js";
 import { sessionRegistryPath, readSessionRegistry, updateSessionRegistry } from "./registry.js";
 import { createSessionWorktree } from "./worktree.js";
+import { mountHarness } from "../harness/mount.js";
 function defaultProbeClaude(env) {
     return new Promise((resolve) => {
         execFile("claude", ["--version"], { env, timeout: 5_000 }, (error, stdout) => {
@@ -131,6 +132,21 @@ export class SessionSupervisor {
                 return;
         }
     }
+    async mountInto(sessionId, root, projectId) {
+        const lookup = this.options.sessions?.harnessManifestUrl;
+        if (!lookup)
+            return;
+        try {
+            const manifestUrl = await lookup.call(this.options.sessions, projectId);
+            if (!manifestUrl)
+                return;
+            await (this.options.mountHarness ?? mountHarness)(root, manifestUrl);
+        }
+        catch (error) {
+            const log = this.options.log ?? ((line) => process.stderr.write(`${line}\n`));
+            log(`nustack: harness mount skipped for session ${sessionId} - ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     async openSession(sessionId, projectPath, permissionMode, isolated, resumeSessionId, commit) {
         if (this.sessions.has(sessionId))
             return this.error(sessionId, "SESSION_ALREADY_OPEN", `session ${sessionId} is already open`);
@@ -158,6 +174,8 @@ export class SessionSupervisor {
             enginePid: process.pid,
             closedAt: null,
         };
+        if (record.projectId)
+            await this.mountInto(sessionId, worktree.worktreePath, record.projectId);
         const adapterOptions = {
             cwd: worktree.worktreePath,
             permissionMode,

package/dist/lib/sessions/client.js

@@ -37,6 +37,18 @@ export function makeSessionsClient(baseUrl, accessToken) {
         async setVendorSessionId(projectId, sessionId, vendorSessionId) {
             return this.transitionSession(projectId, sessionId, "running", { vendorSessionId });
         },
+        async harnessManifestUrl(projectId) {
+            const safeId = assertSafeOpaqueId("The Project id", projectId);
+            const response = await globalThis.fetch(`${baseUrl}/api/v2/projects/${encodeURIComponent(safeId)}`, {
+                headers,
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+            const payload = (await response.json().catch(() => null));
+            if (!response.ok)
+                throw new Error(`project summary fetch failed: HTTP ${response.status}`);
+            const url = payload?.data?.harness?.manifestUrl;
+            return typeof url === "string" && url ? url : null;
+        },
     };
 }
 export function sessionsClientFromEnv(env = process.env) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nurix/nustack",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "description": "The nustack CLI — bootstrap NuStack services into a repo via the NuStack discovery plane.",
   "type": "module",
   "private": false,
@@ -21,13 +21,14 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
+    "@nurix/etna": "0.20.25",
     "ajv": "^8.17.1",
     "ajv-formats": "^3.0.1",
     "commander": "^14.0.0"
   },
   "optionalDependencies": {
-    "@nurix/codegraph": "0.2.1",
-    "@nurix/logscope": "0.1.0"
+    "@nurix/logscope": "0.1.0",
+    "@nurix/codegraph": "0.2.1"
   },
   "devDependencies": {
     "@ngneat/falso": "^8.0.2",