@nurix/nustack 0.23.13 → 0.23.15

package/dist/commands/agent.js

@@ -1,59 +1,7 @@
-import { readFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { installSessionStartHook, removeSessionStartHook } from "../lib/agent/claudeHooks.js";
-const PROBE_TIMEOUT_MS = 1500;
-function desktopConfigDir() {
-    return (process.env.NUSTACK_DESKTOP_CONFIG_DIR ||
-        path.join(os.homedir(), "Library", "Application Support", "co.nurix.nustack"));
-}
-async function readServerRecord() {
-    const recordPath = path.join(desktopConfigDir(), "server.json");
-    try {
-        const parsed = JSON.parse(await readFile(recordPath, "utf8"));
-        if (typeof parsed.port !== "number" ||
-            typeof parsed.token !== "string" ||
-            typeof parsed.pid !== "number" ||
-            typeof parsed.startedAt !== "string") {
-            return null;
-        }
-        return parsed;
-    }
-    catch {
-        return null;
-    }
-}
-function isPidAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        return error.code === "EPERM";
-    }
-}
-function isRosterProject(value) {
-    return (value !== null &&
-        typeof value === "object" &&
-        typeof value.path === "string" &&
-        typeof value.label === "string");
-}
-async function probeProjects(record) {
-    try {
-        const response = await fetch(`http://127.0.0.1:${record.port}/api/projects`, {
-            headers: { Authorization: `Bearer ${record.token}` },
-            signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
-        });
-        if (!response.ok)
-            return null;
-        const body = (await response.json());
-        const projects = body.data?.projects;
-        return Array.isArray(projects) ? projects.filter(isRosterProject) : null;
-    }
-    catch {
-        return null;
-    }
-}
+import { isPidAlive, probeProjects, readServerRecord } from "../lib/agent/desktopDoor.js";
 function describeContext(record, projects) {
     const baseUrl = `http://127.0.0.1:${record.port}`;
     const roster = projects.length

package/dist/commands/obligationList.js

@@ -0,0 +1,75 @@
+import { obligationsCachePath } from "../lib/local_store/paths.js";
+import { printJsonError, printJsonSuccess } from "../lib/json_output.js";
+import { resolveProjectId } from "../lib/project_context.js";
+import { getFromDoor, readCache, writeCache } from "../lib/sessions/brief.js";
+const MAX_PAGES = 100;
+const PAGE_TIMEOUT_MS = 10_000;
+function lineOf(item) {
+    if (typeof item.naturalKey !== "string")
+        return null;
+    const payload = (item.payload ?? {});
+    return {
+        naturalKey: item.naturalKey,
+        state: typeof payload.state === "string" ? payload.state : "unknown",
+        verdict: typeof payload.outcome?.verdict === "string" ? payload.outcome.verdict : null,
+    };
+}
+async function fetchAll(root, globals, projectId, plan) {
+    const lines = [];
+    let cursor = null;
+    for (let page = 0; page < MAX_PAGES; page += 1) {
+        const query = `/records?kind=obligation&planAnchor=${encodeURIComponent(plan)}&limit=100${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`;
+        const answered = await getFromDoor(root, globals, projectId, query, PAGE_TIMEOUT_MS);
+        const items = answered?.data?.items;
+        if (!answered || !Array.isArray(items))
+            return null;
+        for (const item of items) {
+            const line = lineOf(item);
+            if (line)
+                lines.push(line);
+        }
+        cursor = answered.meta?.nextCursor ?? null;
+        if (!cursor)
+            return lines;
+    }
+    return lines;
+}
+export async function runObligationList(options, globals) {
+    const root = process.cwd();
+    const project = await resolveProjectId(root, options.project ? { project: options.project } : {});
+    if (!project.ok) {
+        if (options.json)
+            printJsonError("obligation list", { code: "NO_PROJECT", message: project.message });
+        else {
+            process.stderr.write(`obligation list: ${project.message}\n`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const cacheFile = obligationsCachePath(project.projectId, options.plan);
+    const fetched = await fetchAll(root, globals, project.projectId, options.plan);
+    let obligations;
+    let source;
+    let fetchedAt = null;
+    if (fetched) {
+        writeCache(cacheFile, fetched);
+        obligations = fetched;
+        source = "server";
+    }
+    else {
+        const cached = readCache(cacheFile);
+        obligations = cached?.value ?? [];
+        fetchedAt = cached?.fetchedAt ?? null;
+        source = "cache";
+    }
+    if (options.json) {
+        printJsonSuccess("obligation list", { plan: options.plan, projectId: project.projectId, source, fetchedAt, obligations });
+        return;
+    }
+    if (source === "cache")
+        process.stderr.write(`obligation list: offline; the cached list${fetchedAt ? ` from ${fetchedAt}` : " is empty"}\n`);
+    for (const line of obligations)
+        process.stdout.write(`${line.naturalKey}  ${line.state}${line.verdict ? ` ${line.verdict}` : ""}\n`);
+    if (obligations.length === 0)
+        process.stdout.write(`obligation list: no obligations under ${options.plan}\n`);
+}

package/dist/commands/read.js

@@ -0,0 +1,19 @@
+import { InvalidArgumentError } from "commander";
+import { runReadBulk as runRelay } from "../lib/gate/bulkReadRelay.js";
+import { isReadBulkBudgetInRange, READ_BULK_BUDGET_BOUNDS_MS } from "../lib/gate/settings.js";
+export function parseBudgetMs(value) {
+    const parsed = /^\d+$/.test(value.trim()) ? Number.parseInt(value.trim(), 10) : Number.NaN;
+    if (!isReadBulkBudgetInRange(parsed)) {
+        throw new InvalidArgumentError(`the budget is an integer from ${READ_BULK_BUDGET_BOUNDS_MS.min} to ${READ_BULK_BUDGET_BOUNDS_MS.max} milliseconds.`);
+    }
+    return parsed;
+}
+export function parseLineWindow(value) {
+    if (!/^\d+$/.test(value.trim()) || Number.parseInt(value.trim(), 10) < 1) {
+        throw new InvalidArgumentError("the line window is a positive integer.");
+    }
+    return Number.parseInt(value.trim(), 10);
+}
+export async function runReadBulk(options) {
+    await runRelay(options);
+}

package/dist/commands/recordAliases.js

@@ -3,6 +3,7 @@ import { openLocalStore } from "../lib/local_store/database.js";
 import { idempotencyKeyOf, splitObligationKey } from "../lib/records/naturalKey.js";
 import { findRecordByKey } from "../lib/records/recordsTable.js";
 import { emitRows, refuseEmit, resolveCaller } from "./records.js";
+import { runObligationList } from "./obligationList.js";
 export const RECORD_ALIAS_GROUPS = ["obligation", "backlog", "changelog", "journal"];
 const VERDICTS_NEEDING_REASON = new Set(["owes_nothing", "blocked", "dismissed"]);
 const PLAN_ANCHOR = /^\d{4}-\d{2}-\d{2}-[a-z0-9][a-z0-9-]*$/;
@@ -152,6 +153,13 @@ export function registerRecordAliases(program, getGlobalOptions) {
         .requiredOption("--key <naturalKey>", "the obligation's natural key, <origin>#<type>:<subject>")
         .requiredOption("--outcome <verdict>", "updated, satisfied, fixed, owes_nothing, blocked or dismissed")
         .option("--reason <text>", "why; required for owes_nothing, blocked and dismissed")).action(async (options) => runObligationDischarge(options, getGlobalOptions()));
+    obligation
+        .command("list")
+        .description("List a plan's obligations as NuStack holds them (the cached list when offline)")
+        .requiredOption("--plan <anchor>", "the plan anchor")
+        .option("--project <id>", "the Project, when the folder carries no binding marker")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runObligationList(options, getGlobalOptions()));
     withCommon(program
         .command("backlog")
         .description("Log backlog items (harness records)")

package/dist/commands/records.js

@@ -11,6 +11,7 @@ import { DEVICE_TOKEN_VARIABLE, DRAIN_CHILD_VARIABLE, SESSION_ID_VARIABLE, isFla
 import { UNKNOWN_KIND_MESSAGE, assembleRecord, parseRowsText, translateRow, } from "../lib/records/recordInput.js";
 import { AgentOwnedError, OBLIGATION_AGENT_OWNED, countRecords, hasDueRecord, listRecords, releaseUnboundRows, writeRecords, } from "../lib/records/recordsTable.js";
 import { logRefusals } from "../lib/records/refusalLog.js";
+import { drainSessionLegs } from "../lib/sessions/sessionEvents.js";
 async function readStdin() {
     if (process.stdin.isTTY)
         return "";
@@ -35,23 +36,25 @@ export async function resolveCaller(request) {
         },
     };
 }
-export async function refuseEmit(request, code, gate, message, globals, caller) {
+async function logRefusal(request, gate, message, globals, caller) {
     const who = caller ?? (await resolveCaller(request).catch(() => null));
-    if (who) {
+    if (!who)
+        return;
+    try {
+        const store = await openLocalStore();
         try {
-            const store = await openLocalStore();
-            try {
-                if (logRefusals(store, [{ gate, verdict: "block", target: request.target, reason: message }], who.refusalContext) > 0) {
-                    startDetachedDrain({ nustackUrl: globals.nustackUrl });
-                }
-            }
-            finally {
-                store.close();
+            if (logRefusals(store, [{ gate, verdict: "block", target: request.target, reason: message }], who.refusalContext) > 0) {
+                startDetachedDrain({ nustackUrl: globals.nustackUrl });
             }
         }
-        catch {
+        finally {
+            store.close();
         }
     }
+    catch {
+    }
+}
+function printRefusal(request, code, message) {
     if (request.json)
         printJsonError(request.command, { code, message });
     else {
@@ -59,9 +62,16 @@ export async function refuseEmit(request, code, gate, message, globals, caller)
         process.exitCode = 1;
     }
 }
-export async function emitRows(request, globals) {
+export async function refuseEmit(request, code, gate, message, globals, caller) {
+    await logRefusal(request, gate, message, globals, caller);
+    printRefusal(request, code, message);
+}
+export async function writeRecordsLocally(request, globals) {
     const caller = await resolveCaller(request);
-    const refuse = (code, gate, message) => refuseEmit(request, code, gate, message, globals, caller);
+    const refuse = async (code, gate, message) => {
+        await logRefusal(request, gate, message, globals, caller);
+        return { ok: false, code, message };
+    };
     if (!isEmitKind(request.kind))
         return refuse("VALIDATION_FAILED", "records-unknown-kind", UNKNOWN_KIND_MESSAGE);
     const kind = request.kind;
@@ -110,37 +120,44 @@ export async function emitRows(request, globals) {
             owned = error;
             written = [];
         }
-        if (owned)
-            return;
-        if (caller.projectId !== null)
-            releaseUnboundRows(store, caller.root);
-        logRefusals(store, flags.map((flag) => ({
-            gate: "secret-scan",
-            verdict: "flag",
-            target: request.target,
-            reason: `redacted a ${flag.patternId} match at ${flag.path}`,
-        })), caller.refusalContext);
+        if (!owned) {
+            if (caller.projectId !== null)
+                releaseUnboundRows(store, caller.root);
+            logRefusals(store, flags.map((flag) => ({
+                gate: "secret-scan",
+                verdict: "flag",
+                target: request.target,
+                reason: `redacted a ${flag.patternId} match at ${flag.path}`,
+            })), caller.refusalContext);
+        }
     }
     finally {
         store.close();
-        if (owned)
-            await refuse(OBLIGATION_AGENT_OWNED, "agent-owned-obligation", owned.message);
     }
     if (owned)
-        return;
+        return refuse(OBLIGATION_AGENT_OWNED, "agent-owned-obligation", owned.message);
     if (flags.length > 0 || written.some((row) => row.syncState === "pending"))
         startDetachedDrain({ nustackUrl: globals.nustackUrl });
-    const data = {
-        written: written.length,
-        keys: written.map((row) => row.idempotencyKey),
-        local: written.filter((row) => row.syncState === "local").length,
-        flags,
-        projectId: caller.projectId,
+    return {
+        ok: true,
+        data: {
+            written: written.length,
+            keys: written.map((row) => row.idempotencyKey),
+            local: written.filter((row) => row.syncState === "local").length,
+            flags,
+            projectId: caller.projectId,
+        },
     };
+}
+export async function emitRows(request, globals) {
+    const outcome = await writeRecordsLocally(request, globals);
+    if (!outcome.ok)
+        return printRefusal(request, outcome.code, outcome.message);
+    const data = outcome.data;
     if (request.json)
         printJsonSuccess(request.command, data);
     else {
-        for (const flag of flags)
+        for (const flag of data.flags)
             process.stderr.write(`${request.command}: redacted a ${flag.patternId} match at ${flag.path}\n`);
         process.stdout.write(`${request.command}: wrote ${data.written} record(s) locally; sending in the background\n`);
     }
@@ -159,12 +176,18 @@ export async function runRecordsEmit(options, globals) {
     }, globals);
 }
 async function drainAs(store, globals, isChild) {
-    if (!isChild)
-        return drainRecords(store, globals, { isForeground: true });
+    if (!isChild) {
+        const drained = await drainRecords(store, globals, { isForeground: true });
+        await drainSessionLegs(store, globals);
+        return drained;
+    }
     if (!acquireDrainLock())
         return null;
     try {
-        return await drainRecords(store, globals, { onPass: () => refreshDrainLock() });
+        const drained = await drainRecords(store, globals, { onPass: () => refreshDrainLock() });
+        refreshDrainLock();
+        await drainSessionLegs(store, globals);
+        return drained;
     }
     finally {
         releaseDrainLock();

package/dist/commands/session.js

@@ -0,0 +1,222 @@
+import { appendFileSync } from "node:fs";
+import { openLocalStore } from "../lib/local_store/database.js";
+import { printJsonError, printJsonSuccess } from "../lib/json_output.js";
+import { resolveProjectId } from "../lib/project_context.js";
+import { startDetachedDrain } from "../lib/records/drain.js";
+import { SESSION_ID_VARIABLE, readVariable } from "../lib/records/environment.js";
+import { countRefusals } from "../lib/records/refusalLog.js";
+import { scanPayload } from "../lib/records/secretScan.js";
+import { readBrief, renderBrief, renderHookOutput } from "../lib/sessions/brief.js";
+import { parseHookInput, readAllStdin, resolveModel } from "../lib/sessions/hookInput.js";
+import { shipChangedMemory } from "../lib/sessions/memoryShip.js";
+import { mountFacts } from "../lib/sessions/mountFacts.js";
+import { isSessionRuntime, sessionRowIdOf } from "../lib/sessions/sessionKey.js";
+import { readSpool, spoolEvent } from "../lib/sessions/sessionEvents.js";
+import { writeRecordsLocally } from "./records.js";
+async function hookContext(runtimeFlag, raw) {
+    if (!isSessionRuntime(runtimeFlag))
+        return null;
+    const projectDir = readVariable("CLAUDE_PROJECT_DIR");
+    if (runtimeFlag === "claude_code" && !projectDir)
+        return null;
+    const input = parseHookInput(raw);
+    const engineRowId = readVariable(SESSION_ID_VARIABLE);
+    if (!engineRowId && !input.sessionId)
+        return null;
+    const root = projectDir ?? input.cwd ?? process.cwd();
+    const project = await resolveProjectId(root, {});
+    if (!project.ok)
+        return null;
+    return {
+        input,
+        runtime: runtimeFlag,
+        root,
+        projectId: project.projectId,
+        rowId: engineRowId ?? sessionRowIdOf(runtimeFlag, input.sessionId),
+        isEngineSession: engineRowId !== null,
+    };
+}
+const identityOf = (context) => ({
+    rowId: context.rowId,
+    projectId: context.projectId,
+    root: context.root,
+    runtime: context.runtime,
+    runtimeSessionId: context.input.sessionId,
+    isEngineSession: context.isEngineSession,
+});
+async function refusalCountOf(projectId) {
+    try {
+        const store = await openLocalStore();
+        try {
+            return countRefusals(store, { projectId });
+        }
+        finally {
+            store.close();
+        }
+    }
+    catch {
+        return 0;
+    }
+}
+async function runBriefHook(options, globals) {
+    const context = await hookContext(options.runtime, await readAllStdin());
+    if (!context)
+        return;
+    const facts = await mountFacts(context.root, context.runtime);
+    const model = resolveModel(context.input);
+    const event = {
+        sessionId: context.rowId,
+        ...(context.input.sessionId ? { runtimeSessionId: context.input.sessionId } : {}),
+        phase: "start",
+        occurredAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+        extension: {
+            runtime: context.runtime,
+            ...(model ? { model } : {}),
+            ...(facts.harnessSemver ? { harnessSemver: facts.harnessSemver } : {}),
+            ...(facts.harnessDigest ? { harnessDigest: facts.harnessDigest } : {}),
+            ...(facts.configDigest ? { configDigest: facts.configDigest } : {}),
+        },
+        isEngineSession: context.isEngineSession,
+    };
+    spoolEvent(identityOf(context), event);
+    const envFile = readVariable("CLAUDE_ENV_FILE");
+    if (envFile) {
+        try {
+            appendFileSync(envFile, `export ${SESSION_ID_VARIABLE}=${context.rowId}\n`);
+        }
+        catch {
+        }
+    }
+    startDetachedDrain({ nustackUrl: globals.nustackUrl });
+    const brief = await readBrief(context.root, globals, context.projectId, context.rowId, await refusalCountOf(context.projectId));
+    process.stdout.write(`${renderHookOutput(brief)}\n`);
+}
+export async function runSessionBrief(options, globals) {
+    if (options.hook) {
+        try {
+            await runBriefHook(options, globals);
+        }
+        catch {
+        }
+        process.exitCode = 0;
+        return;
+    }
+    const root = process.cwd();
+    const project = await resolveProjectId(root, options.project ? { project: options.project } : {});
+    if (!project.ok) {
+        if (options.json)
+            printJsonError("session brief", { code: "NO_PROJECT", message: project.message });
+        else {
+            process.stderr.write(`session brief: ${project.message}\n`);
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const sessionId = options.session ?? readVariable(SESSION_ID_VARIABLE);
+    const brief = await readBrief(root, globals, project.projectId, sessionId, await refusalCountOf(project.projectId));
+    if (options.json)
+        printJsonSuccess("session brief", brief);
+    else
+        process.stdout.write(`${renderBrief(brief)}\n`);
+}
+async function handoverOf(flag) {
+    if (flag === undefined)
+        return null;
+    const raw = (flag === "-" ? await readAllStdin() : flag).trim();
+    if (!raw)
+        return null;
+    const scanned = scanPayload({ handover: raw });
+    return { text: scanned.payload.handover.slice(0, 20_000), flags: scanned.flags.length };
+}
+async function runEndHook(options, globals) {
+    const context = await hookContext(options.runtime, await readAllStdin());
+    if (!context)
+        return;
+    if (context.input.hookEventName === "SessionEnd") {
+        const event = {
+            sessionId: context.rowId,
+            ...(context.input.sessionId ? { runtimeSessionId: context.input.sessionId } : {}),
+            phase: "end",
+            occurredAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+            extension: { runtime: context.runtime },
+            isEngineSession: context.isEngineSession,
+        };
+        spoolEvent(identityOf(context), event, { isClosePending: true });
+    }
+    if (context.runtime === "claude_code") {
+        await shipChangedMemory({ repositoryRoot: context.root, projectId: context.projectId, sessionId: context.rowId }, globals, writeRecordsLocally);
+    }
+    startDetachedDrain({ nustackUrl: globals.nustackUrl });
+}
+export async function runSessionEnd(options, globals) {
+    if (options.hook) {
+        try {
+            await runEndHook(options, globals);
+        }
+        catch {
+        }
+        process.exitCode = 0;
+        return;
+    }
+    const refuse = (code, message) => {
+        if (options.json)
+            printJsonError("session end", { code, message });
+        else {
+            process.stderr.write(`session end: ${message}\n`);
+            process.exitCode = 1;
+        }
+    };
+    const handover = await handoverOf(options.handover);
+    if (!handover)
+        return refuse("VALIDATION_FAILED", "a handover is required: --handover <text>, or --handover - to read it from stdin");
+    const rowId = options.session ?? readVariable(SESSION_ID_VARIABLE);
+    if (!rowId)
+        return refuse("NO_SESSION", `no session: run it inside a session (${SESSION_ID_VARIABLE}) or pass --session <id>`);
+    const held = readSpool(rowId);
+    const runtime = held?.runtime ?? (isSessionRuntime(options.runtime) ? options.runtime : "claude_code");
+    let projectId = held?.projectId ?? null;
+    const root = held?.root ?? process.cwd();
+    if (!projectId) {
+        const project = await resolveProjectId(root, options.project ? { project: options.project } : {});
+        if (!project.ok)
+            return refuse("NO_PROJECT", project.message);
+        projectId = project.projectId;
+    }
+    spoolEvent({ rowId, projectId, root, runtime, runtimeSessionId: held?.runtimeSessionId ?? null, isEngineSession: held?.isEngineSession ?? false }, {
+        sessionId: rowId,
+        phase: "end",
+        occurredAt: new Date().toISOString().replace(/\.\d{3}Z$/, "Z"),
+        extension: { runtime, handover: handover.text },
+    });
+    startDetachedDrain({ nustackUrl: globals.nustackUrl });
+    const data = { sessionId: rowId, projectId, redacted: handover.flags };
+    if (options.json)
+        printJsonSuccess("session end", data);
+    else {
+        if (handover.flags > 0)
+            process.stderr.write(`session end: redacted ${handover.flags} secret match(es) in the handover\n`);
+        process.stdout.write("session end: handover recorded; sending in the background\n");
+    }
+}
+export function registerSessionCommands(program, getGlobalOptions) {
+    const session = program.command("session").description("What a session opens with and what it leaves the next one");
+    session
+        .command("brief")
+        .description("The Project's previous handover and open obligations")
+        .option("--hook", "SessionStart hook mode: read the hook JSON on stdin, print the brief as context, always exit 0")
+        .option("--runtime <runtime>", "the runtime reporting: claude_code, codex, opencode, copilot_cli or nustack (required with --hook)")
+        .option("--project <id>", "the Project, when the folder carries no binding marker")
+        .option("--session <id>", `the asking session, left out of the previous handover (default: $${SESSION_ID_VARIABLE})`)
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runSessionBrief(options, getGlobalOptions()));
+    session
+        .command("end")
+        .description("Leave a handover for the next session; in hook mode, ship memory and close the session")
+        .option("--handover <text>", "the handover; - reads it from stdin")
+        .option("--hook", "Stop / SessionEnd hook mode: read the hook JSON on stdin, always exit 0")
+        .option("--runtime <runtime>", "the runtime reporting (required with --hook)")
+        .option("--session <id>", `the session row (default: $${SESSION_ID_VARIABLE})`)
+        .option("--project <id>", "the Project, when the folder carries no binding marker")
+        .option("--json", "emit the versioned machine envelope")
+        .action(async (options) => runSessionEnd(options, getGlobalOptions()));
+}

package/dist/lib/agent/desktopDoor.js

@@ -0,0 +1,55 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const PROBE_TIMEOUT_MS = 1500;
+export function desktopConfigDir() {
+    return (process.env.NUSTACK_DESKTOP_CONFIG_DIR ||
+        path.join(os.homedir(), "Library", "Application Support", "co.nurix.nustack"));
+}
+export async function readServerRecord() {
+    const recordPath = path.join(desktopConfigDir(), "server.json");
+    try {
+        const parsed = JSON.parse(await readFile(recordPath, "utf8"));
+        if (typeof parsed.port !== "number" ||
+            typeof parsed.token !== "string" ||
+            typeof parsed.pid !== "number" ||
+            typeof parsed.startedAt !== "string") {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+export function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+export function isRosterProject(value) {
+    return (value !== null &&
+        typeof value === "object" &&
+        typeof value.path === "string" &&
+        typeof value.label === "string");
+}
+export async function probeProjects(record) {
+    try {
+        const response = await fetch(`http://127.0.0.1:${record.port}/api/projects`, {
+            headers: { Authorization: `Bearer ${record.token}` },
+            signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return null;
+        const body = (await response.json());
+        const projects = body.data?.projects;
+        return Array.isArray(projects) ? projects.filter(isRosterProject) : null;
+    }
+    catch {
+        return null;
+    }
+}