@tea-agent/loop-agent 0.40.0-next.9 → 0.41.0-beta.1

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;
+import { readJsonIfExists, writeSecureJson, } from "../../infrastructure/console/app-data.js";
+import { normalizeWorktreeRealpath, repoFingerprintV1, } from "../../infrastructure/console/repo-fingerprint.js";
+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. */