@tea-agent/loop-agent 0.40.0-next.8 → 0.40.0

package/dist/worker/console/workspace-registry.js

@@ -16,11 +16,12 @@
  *     byte-identical (same ids and order).
  */
 import { createHash, randomBytes } from "node:crypto";
-import { realpathSync, statSync } from "node:fs";
+import { realpathSync, statSync, unwatchFile, watchFile } from "node:fs";
+import { mkdir, open, readFile, rm, stat } from "node:fs/promises";
 import path from "node:path";
 import { readJsonIfExists, writeSecureJson, } from "./app-data.js";
 import { normalizeWorktreeRealpath, repoFingerprintV1, } from "./repo-fingerprint.js";
-export const WORKSPACE_REGISTRY_SCHEMA_VERSION = 1;
+export const WORKSPACE_REGISTRY_SCHEMA_VERSION = 3;
 /** Stable workspaceId: sha256("loop-console-workspace-v1\0" + normalizedRealpath). */
 export function workspaceIdForRealpath(normalizedRealpath) {
     return createHash("sha256")
@@ -31,11 +32,19 @@ export class WorkspaceRegistry {
     appData;
     options;
     file;
-    cache;
+    lockFile;
+    mutationTail = Promise.resolve();
+    listeners = new Set();
+    watching = false;
+    lastObservedRevision = 0;
+    onRegistryFileChanged = () => {
+        void this.load().then((registry) => this.emitRevision(registry.revision));
+    };
     constructor(appData, options = {}) {
         this.appData = appData;
         this.options = options;
         this.file = path.join(appData.root, "workspaces.json");
+        this.lockFile = path.join(appData.root, "workspaces.lock");
     }
     /** Auto-register the startup repoRoot (idempotent). */
     async ensureStartupWorkspace(repoRoot) {
@@ -94,56 +103,72 @@ export class WorkspaceRegistry {
             };
         }
         const normalized = normalizeWorktreeRealpath(real);
-        const existing = await this.findByRealpathNormalized(normalized);
-        if (existing && !existing.hidden) {
-            return {
-                ok: false,
-                code: "DUPLICATE",
-                message: `workspace already registered: ${existing.displayPath}`,
-            };
-        }
         const nowIso = (this.options.now ?? (() => new Date()))().toISOString();
-        if (existing) {
-            // Restore the soft-removed record; identity (workspaceId,
-            // repoFingerprint, createdAt, order) is preserved.
-            existing.hidden = undefined;
-            existing.lastAccessedAt = nowIso;
-            if (options.name && options.name.trim()) {
-                existing.name = options.name.trim();
+        return this.mutate((registry) => {
+            const existing = registry.workspaces.find((workspace) => workspace.displayPath === normalized);
+            if (existing && !existing.hidden) {
+                return {
+                    changed: false,
+                    value: {
+                        ok: false,
+                        code: "DUPLICATE",
+                        message: `workspace already registered: ${existing.displayPath}`,
+                    },
+                };
             }
-            const registry = await this.load();
-            await this.persist(registry);
-            return { ok: true, record: existing, registryUnchanged: false };
-        }
-        const record = {
-            workspaceId: workspaceIdForRealpath(normalized),
-            name: options.name?.trim() || path.basename(normalized) || normalized,
-            displayPath: normalized,
-            repoRoot: real,
-            repoFingerprint: repoFingerprintV1(real),
-            createdAt: nowIso,
-            lastAccessedAt: nowIso,
-        };
-        const registry = await this.load();
-        registry.workspaces.push(record);
-        await this.persist(registry);
-        return { ok: true, record, registryUnchanged: false };
+            if (existing) {
+                // Restore the soft-removed record; identity and order are preserved.
+                existing.hidden = undefined;
+                existing.lastAccessedAt = nowIso;
+                if (options.name?.trim())
+                    existing.name = options.name.trim();
+                return {
+                    changed: true,
+                    value: { ok: true, record: existing, registryUnchanged: false },
+                };
+            }
+            const record = {
+                workspaceId: workspaceIdForRealpath(normalized),
+                name: options.name?.trim() || path.basename(normalized) || normalized,
+                displayPath: normalized,
+                repoRoot: real,
+                repoFingerprint: repoFingerprintV1(real),
+                createdAt: nowIso,
+                lastAccessedAt: nowIso,
+                sessionIds: [],
+            };
+            registry.workspaces.push(record);
+            return {
+                changed: true,
+                value: { ok: true, record, registryUnchanged: false },
+            };
+        });
     }
-    /** Visible list in canonical insertion order. */
+    /** Visible list in canonical persisted order. */
     async listVisible() {
+        return (await this.snapshotVisible()).workspaces;
+    }
+    /** Complete durable registry order, including soft-removed Workspaces. */
+    async listAll() {
+        return (await this.load()).workspaces;
+    }
+    async snapshotVisible() {
         const registry = await this.load();
-        return registry.workspaces.filter((workspace) => {
-            if (workspace.hidden)
-                return false;
-            try {
-                return statSync(workspace.repoRoot).isDirectory();
-            }
-            catch {
-                // Keep historical registry data, but do not project stale test roots
-                // into the Workspace browser after their directories disappear.
-                return false;
-            }
-        });
+        return {
+            revision: registry.revision,
+            workspaces: registry.workspaces.filter((workspace) => {
+                if (workspace.hidden)
+                    return false;
+                try {
+                    return statSync(workspace.repoRoot).isDirectory();
+                }
+                catch {
+                    // Keep historical registry data, but do not project stale test roots
+                    // into the Workspace browser after their directories disappear.
+                    return false;
+                }
+            }),
+        };
     }
     async get(workspaceId) {
         const registry = await this.load();
@@ -163,13 +188,159 @@ export class WorkspaceRegistry {
     }
     /** Soft-remove: hides the record; never touches directories or AppData. */
     async remove(workspaceId) {
-        const registry = await this.load();
-        const record = registry.workspaces.find((w) => w.workspaceId === workspaceId);
-        if (!record || record.hidden)
+        return this.mutate((registry) => {
+            const record = registry.workspaces.find((workspace) => workspace.workspaceId === workspaceId);
+            if (!record || record.hidden)
+                return { changed: false, value: false };
+            record.hidden = true;
+            return { changed: true, value: true };
+        });
+    }
+    /** Move one visible workspace before another; a null anchor moves it last. */
+    async insertBefore(workspaceId, beforeWorkspaceId) {
+        return this.mutate((registry) => {
+            const source = registry.workspaces.find((workspace) => workspace.workspaceId === workspaceId && !workspace.hidden);
+            if (!source) {
+                return {
+                    changed: false,
+                    value: { ok: false, code: "WORKSPACE_NOT_FOUND" },
+                };
+            }
+            if (beforeWorkspaceId === workspaceId) {
+                return {
+                    changed: false,
+                    value: { ok: true, changed: false },
+                };
+            }
+            const anchor = beforeWorkspaceId
+                ? registry.workspaces.find((workspace) => workspace.workspaceId === beforeWorkspaceId && !workspace.hidden)
+                : undefined;
+            if (beforeWorkspaceId && !anchor) {
+                return {
+                    changed: false,
+                    value: { ok: false, code: "ANCHOR_NOT_FOUND" },
+                };
+            }
+            const visibleBefore = registry.workspaces
+                .filter((workspace) => !workspace.hidden)
+                .map((workspace) => workspace.workspaceId);
+            const visibleAfter = visibleBefore.filter((id) => id !== workspaceId);
+            const insertAt = beforeWorkspaceId
+                ? visibleAfter.indexOf(beforeWorkspaceId)
+                : visibleAfter.length;
+            visibleAfter.splice(insertAt, 0, workspaceId);
+            if (visibleAfter.every((id, index) => id === visibleBefore[index])) {
+                return {
+                    changed: false,
+                    value: { ok: true, changed: false },
+                };
+            }
+            registry.workspaces.splice(registry.workspaces.indexOf(source), 1);
+            const rawAnchorIndex = anchor
+                ? registry.workspaces.indexOf(anchor)
+                : registry.workspaces.length;
+            registry.workspaces.splice(rawAnchorIndex, 0, source);
+            return {
+                changed: true,
+                value: { ok: true, changed: true },
+            };
+        });
+    }
+    /** Attach one Session to exactly one Workspace and prepend it to manual order. */
+    async attachSession(workspaceId, sessionId) {
+        const id = sessionId.trim();
+        if (!id)
+            return false;
+        return this.mutate((registry) => {
+            const target = registry.workspaces.find((workspace) => workspace.workspaceId === workspaceId && !workspace.hidden);
+            if (!target)
+                return { changed: false, value: false };
+            const alreadyAttached = target.sessionIds.includes(id);
+            let changed = false;
+            for (const workspace of registry.workspaces) {
+                if (workspace === target)
+                    continue;
+                const without = workspace.sessionIds.filter((candidate) => candidate !== id);
+                if (without.length !== workspace.sessionIds.length) {
+                    workspace.sessionIds = without;
+                    changed = true;
+                }
+            }
+            if (!alreadyAttached) {
+                target.sessionIds.unshift(id);
+                changed = true;
+            }
+            return { changed, value: true };
+        });
+    }
+    /** Remove one Session membership without touching the Session record itself. */
+    async detachSession(workspaceId, sessionId) {
+        const id = sessionId.trim();
+        if (!id)
             return false;
-        record.hidden = true;
-        await this.persist(registry);
-        return true;
+        return this.mutate((registry) => {
+            const target = registry.workspaces.find((workspace) => workspace.workspaceId === workspaceId);
+            if (!target)
+                return { changed: false, value: false };
+            const next = target.sessionIds.filter((candidate) => candidate !== id);
+            if (next.length === target.sessionIds.length) {
+                return { changed: false, value: false };
+            }
+            target.sessionIds = next;
+            return { changed: true, value: true };
+        });
+    }
+    /**
+     * Reconcile a Workspace with its authoritative per-repo Session store.
+     * Existing manual order is retained; newly discovered legacy Sessions are
+     * prepended in discovery order, and missing records are removed from the
+     * membership projection only (their files are never touched).
+     */
+    async reconcileSessions(workspaceId, discoveredSessionIds) {
+        const discovered = [...new Set(discoveredSessionIds.map((id) => id.trim()).filter(Boolean))];
+        return this.mutate((registry) => {
+            const target = registry.workspaces.find((workspace) => workspace.workspaceId === workspaceId && !workspace.hidden);
+            if (!target)
+                return { changed: false, value: false };
+            const discoveredSet = new Set(discovered);
+            let changed = false;
+            for (const workspace of registry.workspaces) {
+                if (workspace === target)
+                    continue;
+                const next = workspace.sessionIds.filter((id) => !discoveredSet.has(id));
+                if (next.length !== workspace.sessionIds.length) {
+                    workspace.sessionIds = next;
+                    changed = true;
+                }
+            }
+            const retained = target.sessionIds.filter((id) => discoveredSet.has(id));
+            const retainedSet = new Set(retained);
+            const additions = discovered.filter((id) => !retainedSet.has(id));
+            const next = [...additions, ...retained];
+            if (next.length !== target.sessionIds.length ||
+                next.some((id, index) => id !== target.sessionIds[index])) {
+                target.sessionIds = next;
+                changed = true;
+            }
+            return { changed, value: changed };
+        });
+    }
+    /** Notify same-Host clients and watch for revisions written by sibling Hosts. */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        if (!this.watching) {
+            this.watching = true;
+            watchFile(this.file, { interval: 500, persistent: false }, this.onRegistryFileChanged);
+        }
+        return () => {
+            this.listeners.delete(listener);
+            if (this.listeners.size === 0)
+                this.stopWatching();
+        };
+    }
+    close() {
+        this.listeners.clear();
+        this.stopWatching();
     }
     async findByRealpath(rawPath) {
         let normalized;
@@ -186,26 +357,128 @@ export class WorkspaceRegistry {
         return registry.workspaces.find((w) => w.displayPath === normalized);
     }
     async load() {
-        if (this.cache)
-            return this.cache;
         const raw = await readJsonIfExists(this.file).catch(() => undefined);
         const registry = {
-            schemaVersion: 1,
+            schemaVersion: WORKSPACE_REGISTRY_SCHEMA_VERSION,
+            revision: raw && Number.isSafeInteger(raw.revision) && (raw.revision ?? -1) >= 0
+                ? raw.revision
+                : 0,
             workspaces: raw && Array.isArray(raw.workspaces)
                 ? raw.workspaces.filter((w) => Boolean(w) &&
                     typeof w === "object" &&
                     typeof w.workspaceId === "string" &&
                     typeof w.displayPath === "string" &&
-                    typeof w.repoRoot === "string")
+                    typeof w.repoRoot === "string").map((workspace) => ({
+                    ...workspace,
+                    sessionIds: Array.isArray(workspace.sessionIds)
+                        ? workspace.sessionIds.filter((id) => typeof id === "string" && Boolean(id.trim()))
+                        : [],
+                }))
                 : [],
         };
-        this.cache = registry;
         return registry;
     }
     async persist(registry) {
         // writeSecureJson is atomic; a reader mid-write sees the previous bytes.
         await writeSecureJson(this.file, registry);
-        this.cache = registry;
+        this.emitRevision(registry.revision);
+    }
+    mutate(op) {
+        return this.serializeMutation(() => this.withFileLock(async () => {
+            // Always reload while holding the cross-process lock. This is the
+            // read-modify-write boundary that prevents stale-cache lost updates.
+            const registry = await this.load();
+            const result = op(registry);
+            if (result.changed) {
+                registry.revision += 1;
+                await this.persist(registry);
+            }
+            return result.value;
+        }));
+    }
+    serializeMutation(op) {
+        const next = this.mutationTail.then(op, op);
+        this.mutationTail = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    async withFileLock(op) {
+        await mkdir(path.dirname(this.lockFile), { recursive: true, mode: 0o700 });
+        const deadline = Date.now() + 15_000;
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                const handle = await open(this.lockFile, "wx", 0o600);
+                try {
+                    await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }), "utf8");
+                    return await op();
+                }
+                finally {
+                    await handle.close().catch(() => undefined);
+                    await rm(this.lockFile, { force: true }).catch(() => undefined);
+                }
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                if (await this.removeAbandonedLock())
+                    continue;
+                if (Date.now() >= deadline) {
+                    throw new Error("workspace registry is busy in another Console process");
+                }
+                await new Promise((resolve) => setTimeout(resolve, Math.min(25 * (attempt + 1), 250)));
+            }
+        }
+    }
+    async removeAbandonedLock() {
+        try {
+            const [body, info] = await Promise.all([
+                readFile(this.lockFile, "utf8"),
+                stat(this.lockFile),
+            ]);
+            const ageMs = Date.now() - info.mtimeMs;
+            if (ageMs >= 60_000) {
+                await rm(this.lockFile, { force: true });
+                return true;
+            }
+            const pid = Number(JSON.parse(body).pid);
+            if (Number.isSafeInteger(pid) && pid > 0) {
+                try {
+                    process.kill(pid, 0);
+                    return false;
+                }
+                catch (error) {
+                    const code = error.code;
+                    if (code !== "ESRCH")
+                        return false;
+                }
+            }
+            if (ageMs < 10_000 && !Number.isSafeInteger(pid)) {
+                return false;
+            }
+            await rm(this.lockFile, { force: true });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    emitRevision(revision) {
+        if (revision <= this.lastObservedRevision)
+            return;
+        this.lastObservedRevision = revision;
+        for (const listener of this.listeners) {
+            try {
+                listener(revision);
+            }
+            catch {
+                /* Projection listeners must never invalidate a durable write. */
+            }
+        }
+    }
+    stopWatching() {
+        if (!this.watching)
+            return;
+        unwatchFile(this.file, this.onRegistryFileChanged);
+        this.watching = false;
     }
 }
 /** Deterministic-looking nonce reserved for tests requiring unique roots. */

package/dist/worker/observe/static/inspect-bootstrap.d.ts

@@ -0,0 +1,8 @@
+export function extractInspectMutationToken(
+	html: string | null | undefined,
+): string | null;
+export function applyInspectMutationToken(
+	token: string | null | undefined,
+): boolean;
+export function inspectAssetHref(href: string | null | undefined): string | null;
+export function isInspectShellHref(href: string | null | undefined): boolean;

package/dist/worker/observe/static/inspect-bootstrap.js

@@ -0,0 +1,57 @@
+/**
+ * Pure helpers for hosted Inspect bootstrap. Safe to import from Node tests.
+ * No DOM, no view modules.
+ */
+
+const INSPECT_MUTATION_TOKEN_RE =
+	/window\.__INSPECT_MUTATION_TOKEN__\s*=\s*("(?:\\.|[^"\\])*")/;
+
+/** Parse the scoped inspect token injected into `/inspect/` HTML. */
+export function extractInspectMutationToken(html) {
+	const match = String(html ?? "").match(INSPECT_MUTATION_TOKEN_RE);
+	if (!match) return null;
+	try {
+		const value = JSON.parse(match[1]);
+		return typeof value === "string" && value.length > 0 ? value : null;
+	} catch {
+		return null;
+	}
+}
+
+export function applyInspectMutationToken(token) {
+	if (typeof globalThis === "undefined") return false;
+	if (typeof token === "string" && token.length > 0) {
+		globalThis.__INSPECT_MUTATION_TOKEN__ = token;
+		return true;
+	}
+	delete globalThis.__INSPECT_MUTATION_TOKEN__;
+	return false;
+}
+
+/** Resolve inspect index.html stylesheet hrefs against `/inspect/` on the Console origin. */
+export function inspectAssetHref(href) {
+	const raw = String(href ?? "").trim();
+	if (!raw) return null;
+	if (
+		/^[a-z][a-z0-9+.-]*:/i.test(raw) ||
+		raw.startsWith("//") ||
+		raw.startsWith("/")
+	) {
+		return raw;
+	}
+	return `/inspect/${raw.replace(/^\.\//, "")}`;
+}
+
+export function isInspectShellHref(href) {
+	const raw = String(href ?? "").trim();
+	if (!raw) return false;
+	if (raw.startsWith("#/") || raw.startsWith("/#/")) return true;
+	if (
+		raw === "/inspect" ||
+		raw.startsWith("/inspect/") ||
+		raw.startsWith("/inspect#")
+	) {
+		return true;
+	}
+	return false;
+}

package/dist/worker/observe/static/inspect-workspace.js

@@ -13,6 +13,7 @@ import {
 } from "./router.js";
 import {
 	isPageVisible,
+	isWorkspaceActive,
 	pauseForegroundTimers,
 	setWorkspaceActive,
 	setWorkspaceScope,
@@ -33,6 +34,12 @@ import { startDagPolling } from "./views/dag.js";
 import { renderNightJobs } from "./views/night.js";
 import { closeDagInspectorOnOutsideClick } from "./views/dag-inspector.js";
 import { mountOperatorChrome } from "./operator-chrome.js";
+import {
+	applyInspectMutationToken,
+	extractInspectMutationToken,
+	inspectAssetHref,
+	isInspectShellHref,
+} from "./inspect-bootstrap.js";
 
 let instance = null;
 let lastInspectHash = "";
@@ -73,6 +80,31 @@ export function navigateInspectPath(path) {
 	return href;
 }
 
+function onInspectRootClick(event) {
+	if (event.defaultPrevented || event.button !== 0) return;
+	if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
+	const target = event.target;
+	if (!(target instanceof Element)) return;
+	const anchor = target.closest("a[href]");
+	if (!anchor) return;
+	const href = anchor.getAttribute("href");
+	if (!isInspectShellHref(href)) return;
+	event.preventDefault();
+	navigateInspectPath(href);
+}
+
+function resumeInspectPolling() {
+	if (!isPageVisible() || !isWorkspaceActive()) return;
+	const r = lastInspectHash
+		? parseHashRouteWithFilters(lastInspectHash)
+		: parseRoute();
+	if (r.view === "dashboard") startDashboardPolling();
+	if (r.view === "run") startRunPolling(r.workerRunId, false);
+	if (r.view === "dag") startDagPolling(r.dagRunId, false);
+	if (r.view === "pool" && uiState.poolAutoRefresh) startPoolView();
+	if (r.view === "task") startTaskPolling(r.featureId, r.taskId);
+}
+
 function startView(routeValue) {
 	if (routeValue.view === "dashboard") {
 		startDashboardPolling(routeValue.scrollTo);
@@ -131,7 +163,12 @@ export async function prepareInspectWorkspace(root) {
 		throw new Error(`Inspect markup HTTP ${res.status}`);
 	}
 	const html = await res.text();
+	applyInspectMutationToken(extractInspectMutationToken(html));
 	const doc = new DOMParser().parseFromString(html, "text/html");
+	for (const link of doc.querySelectorAll('link[rel="stylesheet"]')) {
+		const resolved = inspectAssetHref(link.getAttribute("href"));
+		if (resolved) ensureStylesheet(resolved);
+	}
 	const app = doc.getElementById("app");
 	if (!app) throw new Error("Inspect markup missing #app");
 	root.appendChild(document.importNode(app, true));
@@ -143,15 +180,7 @@ function bindStandaloneListeners() {
 	window.addEventListener("hashchange", () => route());
 	window.addEventListener("load", () => route());
 	document.addEventListener("pointerdown", closeDagInspectorOnOutsideClick);
-	document.addEventListener("visibilitychange", () => {
-		if (!isPageVisible()) return;
-		const r = parseRoute();
-		if (r.view === "dashboard") startDashboardPolling();
-		if (r.view === "run") startRunPolling(r.workerRunId, false);
-		if (r.view === "dag") startDagPolling(r.dagRunId, false);
-		if (r.view === "pool" && uiState.poolAutoRefresh) startPoolView();
-		if (r.view === "task") startTaskPolling(r.featureId, r.taskId);
-	});
+	document.addEventListener("visibilitychange", resumeInspectPolling);
 }
 
 export function startStandaloneInspect() {
@@ -204,7 +233,6 @@ export function mountInspectWorkspace(root, options = {}) {
 	// workspaceId via mount options/hash and postMessage updates; every observe
 	// GET is then scoped via scopedApiUrl.
 	setWorkspaceScope(options.workspaceId ?? workspaceIdFromHash(options.hash));
-	window.addEventListener("message", onWorkspaceScopeMessage);
 
 	const hosted = options.hosted === true || options.hosted !== false;
 	const onNavigate =
@@ -216,6 +244,20 @@ export function mountInspectWorkspace(root, options = {}) {
 	lastInspectHash = options.hash || (typeof location !== "undefined" ? location.hash : "");
 	setWorkspaceActive(options.active !== false);
 
+	const listenerAbort =
+		typeof AbortController !== "undefined" ? new AbortController() : null;
+	const listenerOpts = listenerAbort ? { signal: listenerAbort.signal } : undefined;
+	window.addEventListener("message", onWorkspaceScopeMessage, listenerOpts);
+	if (hosted && typeof document !== "undefined") {
+		document.addEventListener(
+			"pointerdown",
+			closeDagInspectorOnOutsideClick,
+			listenerOpts,
+		);
+		document.addEventListener("visibilitychange", resumeInspectPolling, listenerOpts);
+		root.addEventListener("click", onInspectRootClick, listenerOpts);
+	}
+
 	const host = {
 		root,
 		hosted,
@@ -250,6 +292,8 @@ export function mountInspectWorkspace(root, options = {}) {
 			host.destroyed = true;
 			pauseForegroundTimers();
 			setNavigateHandler(null);
+			listenerAbort?.abort();
+			if (hosted) applyInspectMutationToken(null);
 			if (instance === host) instance = null;
 		},
 	};