@tea-agent/loop-agent 0.39.3 → 0.40.0-beta.2

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

@@ -0,0 +1,260 @@
+/**
+ * Repo-scoped Workspace Context (2026-08-22 multi-workspace foundation, W1).
+ *
+ * One lazily-created ConsoleContext per workspaceId. Each context INDEPENDENTLY
+ * owns the full operator runtime for its repo root: fingerprint-isolated
+ * appData (via openConsoleAppData), operation/event stores, draft /
+ * confirmation / receipt / interview / assessment stores, Chat session store +
+ * events + deferred Turn registry + ConsolePiRuntime(cwd=repoRoot),
+ * OperatorActionContext, Observe route context, and readiness.
+ *
+ * Invariants:
+ *   - Selecting (viewing) another workspace NEVER disposes a context; running
+ *     Turns / Operations / DAGs continue in the background.
+ *   - dispose() is invoked exactly once per context by the owning server's
+ *     close().
+ *   - bootToken is shared per Console boot: it binds the startup fingerprint
+ *     and bind host, and its confirmationToken signs human-gate tokens for all
+ *     workspaces in this process (single Console security domain).
+ */
+import { randomBytes } from "node:crypto";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { LoopAgentClient } from "../loop-agent/loop-agent-client.js";
+import { openConsoleAppData, } from "../../infrastructure/console/app-data.js";
+import { DagConfirmationStore } from "./dag-confirmation.js";
+import { DagExecutionReceiptStore } from "./dag-execution-receipt.js";
+import { DraftStore } from "./draft-store.js";
+import { AssessmentStore } from "./interview/assessment.js";
+import { InterviewSessionStore } from "./interview/session.js";
+import { ChatSessionStore } from "./chat/session-store.js";
+import { createChatEventStore, createChatOperationLinker, } from "./chat/chat-event-store.js";
+import { createChatTurnExecutionRegistry } from "./chat/turn-execution-registry.js";
+import { ConsolePiRuntime } from "./chat/pi-runtime.js";
+import { UserQuestionRegistry } from "./chat/user-questions.js";
+import { TodoListRegistry } from "./chat/todos.js";
+import { createOperationEventStore, } from "./operation-sse.js";
+import { OperationStore } from "../../infrastructure/console/operation-store.js";
+import { reconcileContextExports } from "../../infrastructure/console/context-export-store.js";
+import { reconcileArtifactRevisions } from "../../infrastructure/console/artifact-revision-store.js";
+import { recordContextTransferEvent } from "./context-transfer-diagnostics.js";
+import { probePiReadiness, } from "./pi-readiness.js";
+import { resolveSiblingLoopAgentBin } from "./sibling-controller.js";
+import { NightAuxTicker } from "./night-aux-ticker.js";
+import { createObserveRouteContext, } from "../observe/routes.js";
+import { WorkspaceRegistry } from "./workspace-registry.js";
+import { resolveConsoleDefaultTimeoutMs } from "./server.js";
+/**
+ * Lazily create the full repo-scoped Console context for a registered
+ * workspace record. Pure factory — no global registry; the caller owns
+ * lifecycle (single creation per workspaceId, dispose on server close).
+ */
+export async function createWorkspaceContext(record, deps) {
+    const repoRoot = record.repoRoot;
+    const appData = openConsoleAppData({
+        repoRoot,
+        ...(deps.appDataRoot ? { appDataRoot: deps.appDataRoot } : {}),
+    });
+    const registry = new WorkspaceRegistry(appData);
+    const readiness = await probePiReadiness({
+        override: deps.piReadinessProbe,
+        repoRoot,
+    });
+    let readinessCache = readiness;
+    const artifactRoot = path.join(appData.root, "client-artifacts", appData.fingerprint);
+    const client = deps.createClient?.(artifactRoot) ??
+        new LoopAgentClient({
+            loopAgentBin: resolveSiblingLoopAgentBin(),
+            artifactRoot,
+            resolveIdentity: true,
+            defaultTimeoutMs: resolveConsoleDefaultTimeoutMs(deps.defaultTimeoutMs),
+        });
+    const operations = new OperationStore(appData);
+    const events = createOperationEventStore({
+        persistenceDir: path.join(appData.operations, "events"),
+    });
+    const drafts = new DraftStore(appData);
+    const confirmations = new DagConfirmationStore(appData, deps.bootToken.confirmationToken);
+    const dagExecutionReceipts = new DagExecutionReceiptStore(appData);
+    const interviews = new InterviewSessionStore(appData);
+    const assessments = new AssessmentStore(appData);
+    if (!deps.skipReconcile) {
+        await operations.reconcileOnBoot();
+        const [expiredExports, expiredRevisions] = await Promise.all([
+            reconcileContextExports({ appData }),
+            reconcileArtifactRevisions({ appData }),
+        ]);
+        // Boot-time lifecycle evidence for what reconcile reclaimed. Only
+        // 32-hex ids are real export/revision identities; uploads/ and lock/
+        // entries are blob housekeeping and get no event.
+        await Promise.all([
+            ...expiredExports.removed
+                .filter((exportId) => /^[a-f0-9]{32}$/.test(exportId))
+                .map((exportId) => recordContextTransferEvent({
+                appData,
+                event: "context_export.expired",
+                fields: { exportId },
+            }).catch(() => undefined)),
+            ...expiredRevisions
+                .filter((revisionId) => /^[a-f0-9]{32}$/.test(revisionId))
+                .map((revisionId) => recordContextTransferEvent({
+                appData,
+                event: "artifact_revision.expired",
+                fields: { revisionId },
+            }).catch(() => undefined)),
+        ]);
+    }
+    const getReadiness = () => readinessCache;
+    const refreshReadiness = async () => {
+        readinessCache = await probePiReadiness({
+            override: deps.piReadinessProbe,
+            repoRoot,
+        });
+        actionContext.readiness = readinessCache;
+        return readinessCache;
+    };
+    const actionContext = {
+        repoRoot,
+        appData,
+        operatorSessionId: deps.operatorSessionId,
+        client,
+        operations,
+        events,
+        drafts,
+        confirmations,
+        dagExecutionReceipts,
+        humanGateSecret: deps.bootToken.confirmationToken,
+        interviews,
+        assessments,
+        readiness: readinessCache,
+        getReadiness,
+        refreshReadiness,
+        observeBaseUrl: deps.observeBaseUrl,
+        fetchImpl: deps.fetchImpl,
+        getConsoleOrigin: deps.getConsoleOrigin,
+    };
+    const chatStore = new ChatSessionStore(appData);
+    const chatEventEpoch = randomBytes(12).toString("hex");
+    const chatEvents = createChatEventStore({
+        appData,
+        epoch: chatEventEpoch,
+    });
+    const chatTurnExecutions = createChatTurnExecutionRegistry();
+    const questionRegistry = new UserQuestionRegistry(path.join(appData.chats, "user-questions"));
+    const todoRegistry = new TodoListRegistry();
+    questionRegistry.subscribe((change) => {
+        const question = change.question;
+        chatEvents.append(question.sessionId, question.turnId ?? `${question.sessionId}:question`, {
+            kind: `question_${change.type}`,
+            data: { question },
+        });
+    });
+    todoRegistry.subscribe((change) => {
+        chatEvents.append(change.sessionId, change.turnId ?? `${change.sessionId}:todo`, {
+            kind: change.type === "updated" ? "todo_updated" : "todo_cleared",
+            data: {
+                todos: change.todos,
+                ...(change.toolCallId ? { toolCallId: change.toolCallId } : {}),
+            },
+        });
+    });
+    const chatOperationLinker = createChatOperationLinker({
+        chatEvents,
+        operations,
+        operationEvents: events,
+    });
+    const chatRuntime = new ConsolePiRuntime({
+        cwd: repoRoot,
+        sessionDir: appData.chatSessions,
+        resourcePreferencesPath: appData.resourcePreferences,
+        actionContext,
+        questionRegistry,
+        todoRegistry,
+    });
+    const chatRouteDeps = {
+        runtime: chatRuntime,
+        store: chatStore,
+        events: chatEvents,
+        turnExecutions: chatTurnExecutions,
+        questionRegistry,
+        todoRegistry,
+        operationLinker: chatOperationLinker,
+        appData,
+        bootToken: deps.bootToken,
+        getConsoleOrigin: deps.getConsoleOrigin,
+        allowNonLoopbackAccess: deps.allowNonLoopbackAccess,
+    };
+    const { recoverDeferredTurns } = await import("./chat/routes.js");
+    const nightAuxTicker = new NightAuxTicker({ repoRoot, client });
+    const observeRouteContext = createObserveRouteContext(repoRoot, {
+        staticDir: deps.inspectStaticDir,
+    });
+    let disposed = false;
+    const context = {
+        workspaceId: record.workspaceId,
+        record,
+        repoRoot,
+        appData,
+        registry,
+        client,
+        operations,
+        events,
+        drafts,
+        confirmations,
+        dagExecutionReceipts,
+        interviews,
+        assessments,
+        chatRouteDeps,
+        chatOperationLinker,
+        chatRuntime,
+        nightAuxTicker,
+        actionContext,
+        observeRouteContext,
+        getReadiness,
+        refreshReadiness,
+        recoverDeferredTurns: () => recoverDeferredTurns(chatRouteDeps),
+        dispose: () => {
+            if (disposed)
+                return;
+            disposed = true;
+            try {
+                chatOperationLinker.dispose();
+            }
+            catch {
+                // best-effort
+            }
+            try {
+                chatRuntime.disposeAll();
+            }
+            catch {
+                // best-effort
+            }
+            try {
+                nightAuxTicker.dispose();
+            }
+            catch {
+                // best-effort
+            }
+        },
+    };
+    return context;
+}
+/** Inspect-facing readiness/capability summary for a registry record. */
+export async function summarizeWorkspaceRecord(record, deps) {
+    let state;
+    try {
+        const report = await probePiReadiness({
+            override: deps.piReadinessProbe,
+            repoRoot: record.repoRoot,
+        });
+        state = report.state;
+    }
+    catch {
+        state = "setup-required";
+    }
+    return {
+        state,
+        summary: `pi=${state}; inspect=${deps.inspectReady ? "ready" : "unavailable"}`,
+    };
+}
+void existsSync;

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

@@ -0,0 +1,214 @@
+/**
+ * User-level Workspace Registry (2026-08-22 multi-workspace foundation, W1).
+ *
+ * Persists the set of registered Console workspaces at
+ * `<appDataRoot>/workspaces.json` (user level, shared across Console boots),
+ * independent of per-repo fingerprint namespaces.
+ *
+ * Invariants:
+ *   - workspaceId is stable per normalized realpath: it is derived from
+ *     sha256("loop-console-workspace-v1\0" + realpath) and never minted twice.
+ *   - REMOVE is soft (hidden=true); on-disk directories, AppData namespaces,
+ *     Sessions, Operations and DAGs are never deleted.
+ *   - Re-adding a previously removed workspace RESTORES the original record
+ *     (same workspaceId + repoFingerprint; only lastAccessedAt advances).
+ *   - Duplicate visible realpath is rejected; add failures leave the registry
+ *     byte-identical (same ids and order).
+ */
+import { createHash, randomBytes } from "node:crypto";
+import { realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { readJsonIfExists, writeSecureJson, } from "../../infrastructure/console/app-data.js";
+import { normalizeWorktreeRealpath, repoFingerprintV1, } from "../../infrastructure/console/repo-fingerprint.js";
+export const WORKSPACE_REGISTRY_SCHEMA_VERSION = 1;
+/** Stable workspaceId: sha256("loop-console-workspace-v1\0" + normalizedRealpath). */
+export function workspaceIdForRealpath(normalizedRealpath) {
+    return createHash("sha256")
+        .update(`loop-console-workspace-v1\0${normalizedRealpath}`, "utf8")
+        .digest("hex");
+}
+export class WorkspaceRegistry {
+    appData;
+    options;
+    file;
+    cache;
+    constructor(appData, options = {}) {
+        this.appData = appData;
+        this.options = options;
+        this.file = path.join(appData.root, "workspaces.json");
+    }
+    /** Auto-register the startup repoRoot (idempotent). */
+    async ensureStartupWorkspace(repoRoot) {
+        const record = await this.add(repoRoot);
+        if (record.ok)
+            return record.record;
+        // Startup root may already be visible (duplicate) or previously hidden —
+        // re-adding a hidden record restores it via add(); the only expected
+        // failure left is DUPLICATE (already visible), which returns the existing.
+        const existing = await this.findByRealpath(repoRoot);
+        if (existing)
+            return existing;
+        throw new Error(`workspace registry: startup root rejected: ${record.code}`);
+    }
+    /**
+     * Register (or restore) a workspace directory.
+     * Failures never mutate the persisted registry.
+     * `options.name` overrides the default directory-name label.
+     */
+    async add(rawPath, options = {}) {
+        const trimmed = rawPath.trim();
+        if (!trimmed) {
+            return {
+                ok: false,
+                code: "INVALID_PATH",
+                message: "path is required",
+            };
+        }
+        let real;
+        try {
+            real = realpathSync(path.resolve(trimmed));
+        }
+        catch {
+            return {
+                ok: false,
+                code: "NOT_A_DIRECTORY",
+                message: `path does not exist: ${trimmed}`,
+            };
+        }
+        let st;
+        try {
+            st = statSync(real);
+        }
+        catch {
+            return {
+                ok: false,
+                code: "UNREADABLE",
+                message: `path is not readable: ${trimmed}`,
+            };
+        }
+        if (!st.isDirectory()) {
+            return {
+                ok: false,
+                code: "NOT_A_DIRECTORY",
+                message: `path is not a directory: ${trimmed}`,
+            };
+        }
+        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();
+            }
+            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 };
+    }
+    /** Visible list in canonical insertion order. */
+    async listVisible() {
+        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;
+            }
+        });
+    }
+    async get(workspaceId) {
+        const registry = await this.load();
+        return registry.workspaces.find((w) => w.workspaceId === workspaceId);
+    }
+    /** Get a VISIBLE workspace by id (removed workspaces are not operable). */
+    async getVisible(workspaceId) {
+        const record = await this.get(workspaceId);
+        if (!record || record.hidden)
+            return undefined;
+        try {
+            return statSync(record.repoRoot).isDirectory() ? record : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** 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 false;
+        record.hidden = true;
+        await this.persist(registry);
+        return true;
+    }
+    async findByRealpath(rawPath) {
+        let normalized;
+        try {
+            normalized = normalizeWorktreeRealpath(path.resolve(rawPath.trim()));
+        }
+        catch {
+            return undefined;
+        }
+        return this.findByRealpathNormalized(normalized);
+    }
+    async findByRealpathNormalized(normalized) {
+        const registry = await this.load();
+        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,
+            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")
+                : [],
+        };
+        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;
+    }
+}
+/** Deterministic-looking nonce reserved for tests requiring unique roots. */
+export function mintWorkspaceNonce() {
+    return randomBytes(8).toString("hex");
+}