@akira-tl/forgerelay 0.8.4 → 0.8.6

package/dist/remote-workspace-relay.js

@@ -2,7 +2,8 @@ import { randomBytes } from "node:crypto";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
-import { isRemoteMcpUnauthorized, refreshRemoteAuthentication, withRemoteMcpClient, } from "./remote-auth.js";
+import { isRemoteMcpUnauthorized, refreshRemoteAuthentication, } from "./remote-auth.js";
+import { RemoteMcpConnectionPool } from "./remote-mcp-connection-pool.js";
 import { withRemoteServiceEndpoint } from "./remote-transport.js";
 import { loadForgeRelayFiles, writeForgeRelayRemote, } from "./user-config.js";
 const ROUTE_LOCK_RETRY_MS = 10;
@@ -15,6 +16,7 @@ export class RemoteWorkspaceRelay {
     authEnv;
     routeStateDir;
     routeStatePath;
+    mcpConnections = new RemoteMcpConnectionPool();
     constructor(configDir, stateDir) {
         this.authEnv = { FORGERELAY_CONFIG_DIR: configDir };
         this.routeStateDir = stateDir;
@@ -27,20 +29,60 @@ export class RemoteWorkspaceRelay {
         this.loadRoutes();
         return this.routes.has(workspaceId);
     }
-    inspectWorkspace(gatewayWorkspaceId) {
+    async shutdown() {
+        await this.mcpConnections.closeAll();
+    }
+    async inspectWorkspace(gatewayWorkspaceId) {
         const route = this.requireRoute(gatewayWorkspaceId);
         const resolved = this.remoteByInstance(route.remoteInstanceId);
-        return {
+        let result;
+        try {
+            result = await this.callRemoteTool(resolved.alias, resolved.remote, "open_workspace", {
+                action: "inspect",
+                workspaceId: route.remoteWorkspaceId,
+            });
+            assertRemoteToolSucceeded(resolved.alias, "open_workspace", result);
+        }
+        catch (error) {
+            throw sanitizedRemoteError(error, route.remoteWorkspaceId, gatewayWorkspaceId);
+        }
+        const structured = result.structuredContent;
+        const remoteInspection = structured?.inspection;
+        if (!remoteInspection || remoteInspection.kind !== "workspace") {
+            throw new Error(`Remote ForgeRelay ${resolved.alias} inspection did not return a Workspace projection.`);
+        }
+        const root = stringField(remoteInspection, "root", "Remote Workspace inspection");
+        const mode = remoteInspection.mode;
+        if (mode !== "checkout" && mode !== "worktree") {
+            throw new Error(`Remote ForgeRelay ${resolved.alias} inspection did not return a valid Workspace mode.`);
+        }
+        const projection = {
             workspaceId: route.gatewayWorkspaceId,
             kind: "workspace",
             location: "relay",
-            root: route.root,
+            root,
             routeState: "known",
-            mode: route.mode,
-            ...(route.sourceRoot ? { sourceRoot: route.sourceRoot } : {}),
+            mode,
             relay: resolved.alias,
             executionLocation: `remote:${resolved.alias}`,
         };
+        copyStringField(remoteInspection, projection, "status");
+        const state = remoteInspection.state;
+        if (state === "active" || state === "stale" || state === "invalid" || state === "closed") {
+            projection.state = state;
+        }
+        copyStringField(remoteInspection, projection, "sourceRoot");
+        copyStringField(remoteInspection, projection, "branch");
+        copyStringField(remoteInspection, projection, "targetBranch");
+        copyBooleanField(remoteInspection, projection, "managed");
+        copyStringField(remoteInspection, projection, "createdAt");
+        copyStringField(remoteInspection, projection, "lastUsedAt");
+        copyNumberField(remoteInspection, projection, "idleMs");
+        copyBooleanField(remoteInspection, projection, "rootValid");
+        const taskSummary = safeTaskSummary(remoteInspection.taskSummary);
+        if (taskSummary)
+            projection.taskSummary = taskSummary;
+        return projection;
     }
     async openWorkspace(alias, input, conversationScopeId) {
         const resolved = this.remoteByAlias(alias);
@@ -66,18 +108,15 @@ export class RemoteWorkspaceRelay {
         if (mode !== "checkout" && mode !== "worktree") {
             throw new Error("Remote open_workspace response did not include a valid workspace mode.");
         }
-        const gatewayWorkspaceId = this.allocateGatewayWorkspaceId();
         const sourceRoot = typeof structured?.sourceRoot === "string" ? structured.sourceRoot : undefined;
-        const route = {
-            gatewayWorkspaceId,
+        const route = this.findOrCreateRoute({
             remoteInstanceId: resolved.remote.instanceId,
             remoteWorkspaceId,
             root,
             mode,
             ...(sourceRoot ? { sourceRoot } : {}),
-        };
-        this.routes.set(gatewayWorkspaceId, route);
-        this.persistRoute(route);
+        });
+        const gatewayWorkspaceId = route.gatewayWorkspaceId;
         const remapContext = (value) => replaceExactWorkspaceId(value, remoteWorkspaceId, gatewayWorkspaceId);
         const remoteInstruction = typeof structured?.instruction === "string"
             ? String(remapContext(structured.instruction))
@@ -117,10 +156,24 @@ export class RemoteWorkspaceRelay {
         };
     }
     async resumeWorkspace(gatewayWorkspaceId, context = "auto", conversationScopeId) {
+        const route = this.requireRoute(gatewayWorkspaceId);
         const result = await this.callWorkspaceTool(gatewayWorkspaceId, "open_workspace", { context }, conversationScopeId);
         if (result.isError === true) {
             throw new Error(`Remote open_workspace failed: ${toolResultText(result)}`);
         }
+        const structured = result.structuredContent;
+        const root = typeof structured?.root === "string" ? structured.root : route.root;
+        const mode = structured?.mode === "checkout" || structured?.mode === "worktree"
+            ? structured.mode
+            : route.mode;
+        const sourceRoot = typeof structured?.sourceRoot === "string" ? structured.sourceRoot : route.sourceRoot;
+        this.findOrCreateRoute({
+            remoteInstanceId: route.remoteInstanceId,
+            remoteWorkspaceId: route.remoteWorkspaceId,
+            root,
+            mode,
+            ...(sourceRoot ? { sourceRoot } : {}),
+        });
         return result;
     }
     async read(gatewayWorkspaceId, input, conversationScopeId) {
@@ -187,11 +240,14 @@ export class RemoteWorkspaceRelay {
             throw sanitizedRemoteError(error, route.remoteWorkspaceId, gatewayWorkspaceId);
         }
     }
+    async activityIndex(turnId, knownRevision, conversationScopeId) {
+        return this.callTurnTool(turnId, "activity_index", { turnId, ...(knownRevision !== undefined ? { knownRevision } : {}) }, conversationScopeId);
+    }
     async activityDetail(turnId, activityId, conversationScopeId) {
         return this.callTurnTool(turnId, "activity_detail", { turnId, activityId }, conversationScopeId);
     }
-    async activityOutput(turnId, outputId, conversationScopeId) {
-        return this.callTurnTool(turnId, "activity_output", { turnId, outputId }, conversationScopeId);
+    async activityOutput(turnId, outputId, conversationScopeId, cursor) {
+        return this.callTurnTool(turnId, "activity_output", { turnId, outputId, ...(cursor !== undefined ? { cursor } : {}) }, conversationScopeId);
     }
     async callTurnTool(turnId, name, args, conversationScopeId) {
         const gatewayWorkspaceId = this.turnRoutes.get(turnId);
@@ -221,14 +277,16 @@ export class RemoteWorkspaceRelay {
             throw sanitizedRemoteError(error, route.remoteWorkspaceId, gatewayWorkspaceId);
         }
     }
-    async closeWorkspace(gatewayWorkspaceId, commitMessage, conversationScopeId) {
+    async closeWorkspace(gatewayWorkspaceId, input = {}, conversationScopeId) {
         const route = this.requireRoute(gatewayWorkspaceId);
         const resolved = this.remoteByInstance(route.remoteInstanceId);
+        const action = input.action ?? "close";
         let result;
         try {
             result = await this.callRemoteTool(resolved.alias, resolved.remote, "close_workspace", {
                 workspaceId: route.remoteWorkspaceId,
-                ...(commitMessage !== undefined ? { commitMessage } : {}),
+                action,
+                ...(input.commitMessage !== undefined ? { commitMessage: input.commitMessage } : {}),
             }, conversationScopeId);
             assertRemoteToolSucceeded(resolved.alias, "close_workspace", result);
         }
@@ -236,21 +294,26 @@ export class RemoteWorkspaceRelay {
             throw sanitizedRemoteError(error, route.remoteWorkspaceId, gatewayWorkspaceId);
         }
         const remoteStructured = result.structuredContent;
-        this.routes.delete(gatewayWorkspaceId);
-        this.deletePersistedRoute(gatewayWorkspaceId);
+        if (action === "delete") {
+            this.routes.delete(gatewayWorkspaceId);
+            this.deletePersistedRoute(gatewayWorkspaceId);
+        }
         for (const [turnId, routedWorkspaceId] of this.turnRoutes) {
             if (routedWorkspaceId === gatewayWorkspaceId)
                 this.turnRoutes.delete(turnId);
         }
+        const actionText = action === "delete" ? "Deleted" : "Closed";
         const text = route.mode === "worktree"
-            ? `Closed relayed worktree workspace ${gatewayWorkspaceId} on remote ${resolved.alias}.`
-            : `Closed relayed checkout workspace ${gatewayWorkspaceId} on remote ${resolved.alias}.`;
+            ? `${actionText} relayed worktree workspace ${gatewayWorkspaceId} on remote ${resolved.alias}.`
+            : `${actionText} relayed checkout workspace ${gatewayWorkspaceId} on remote ${resolved.alias}.`;
         const structuredContent = {
             result: text,
             workspaceId: gatewayWorkspaceId,
+            action,
             mode: route.mode,
         };
         for (const field of [
+            "status",
             "sourceRoot",
             "branch",
             "targetBranch",
@@ -270,6 +333,7 @@ export class RemoteWorkspaceRelay {
                 tool: "close_workspace",
                 card: {
                     workspaceId: gatewayWorkspaceId,
+                    action,
                     mode: route.mode,
                     payload: { content: [{ type: "text", text }] },
                 },
@@ -292,10 +356,26 @@ export class RemoteWorkspaceRelay {
             this.routes.set(workspaceId, route);
         }
     }
-    persistRoute(route) {
-        this.updatePersistedRoutes((routes) => {
-            routes.set(route.gatewayWorkspaceId, route);
+    findOrCreateRoute(input) {
+        let selected;
+        mkdirSync(this.routeStateDir, { recursive: true });
+        this.withRouteFileLock(() => {
+            const routes = this.readRoutesFromDisk();
+            const existing = [...routes.values()]
+                .filter((route) => route.remoteInstanceId === input.remoteInstanceId &&
+                route.remoteWorkspaceId === input.remoteWorkspaceId)
+                .sort((left, right) => left.gatewayWorkspaceId.localeCompare(right.gatewayWorkspaceId))[0];
+            selected = {
+                gatewayWorkspaceId: existing?.gatewayWorkspaceId ?? this.allocateGatewayWorkspaceId(routes),
+                ...input,
+            };
+            routes.set(selected.gatewayWorkspaceId, selected);
+            this.writeRoutesToDisk(routes);
         });
+        if (!selected)
+            throw new Error("Failed to persist relayed Workspace route.");
+        this.routes.set(selected.gatewayWorkspaceId, selected);
+        return selected;
     }
     deletePersistedRoute(workspaceId) {
         this.updatePersistedRoutes((routes) => {
@@ -392,42 +472,64 @@ export class RemoteWorkspaceRelay {
         return { alias: entry[0], remote: entry[1] };
     }
     async callRemoteTool(alias, initialRemote, name, args, conversationScopeId) {
-        return withRemoteServiceEndpoint(initialRemote.target, initialRemote.sshRoute, async (endpoint) => {
-            let remote = initialRemote;
-            let refreshed = false;
-            if (remote.accessTokenExpiresAt <= Math.floor(Date.now() / 1000)) {
-                remote = await this.refreshRemote(alias, remote, endpoint);
+        let remote = initialRemote;
+        let refreshed = false;
+        if (remote.accessTokenExpiresAt <= Math.floor(Date.now() / 1000)) {
+            remote = await withRemoteServiceEndpoint(remote.target, remote.sshRoute, (endpoint) => this.refreshRemote(alias, remote, endpoint));
+            refreshed = true;
+        }
+        let connection;
+        try {
+            connection = await this.mcpConnections.get(remote);
+        }
+        catch (error) {
+            if (!refreshed && isRemoteMcpUnauthorized(error)) {
+                remote = await withRemoteServiceEndpoint(remote.target, remote.sshRoute, (endpoint) => this.refreshRemote(alias, remote, endpoint));
                 refreshed = true;
+                connection = await this.mcpConnections.get(remote);
             }
-            const invoke = () => withRemoteMcpClient(remote, endpoint, async (client) => CallToolResultSchema.parse(await client.callTool({
-                name,
-                arguments: args,
-                ...(conversationScopeId
-                    ? { _meta: { "openai/session": conversationScopeId } }
-                    : {}),
-            })));
-            try {
-                return await invoke();
+            else {
+                throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(error)}`, { cause: error });
             }
-            catch (error) {
-                if (!refreshed && isRemoteMcpUnauthorized(error)) {
-                    remote = await this.refreshRemote(alias, remote, endpoint);
-                    return invoke();
+        }
+        const invoke = async (active) => CallToolResultSchema.parse(await active.client.callTool({
+            name,
+            arguments: args,
+            ...(conversationScopeId
+                ? { _meta: { "openai/session": conversationScopeId } }
+                : {}),
+        }));
+        try {
+            return await invoke(connection);
+        }
+        catch (error) {
+            if (!refreshed && isRemoteMcpUnauthorized(error)) {
+                remote = await this.refreshRemote(alias, remote, connection.endpoint);
+                refreshed = true;
+                await this.mcpConnections.invalidate(remote.instanceId, connection);
+                const refreshedConnection = await this.mcpConnections.get(remote);
+                try {
+                    return await invoke(refreshedConnection);
+                }
+                catch (retryError) {
+                    await this.mcpConnections.invalidate(remote.instanceId, refreshedConnection);
+                    throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(retryError)}`, { cause: retryError });
                 }
-                throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(error)}`, { cause: error });
             }
-        });
+            await this.mcpConnections.invalidate(remote.instanceId, connection);
+            throw new Error(`Remote ForgeRelay ${alias} request failed: ${errorMessage(error)}`, { cause: error });
+        }
     }
     async refreshRemote(alias, remote, endpoint) {
         const refreshed = await refreshRemoteAuthentication(remote, endpoint);
         writeForgeRelayRemote(alias, refreshed, this.authEnv);
         return refreshed;
     }
-    allocateGatewayWorkspaceId() {
+    allocateGatewayWorkspaceId(routes = this.routes) {
         let workspaceId;
         do {
             workspaceId = `rws_${randomBytes(5).toString("hex")}`;
-        } while (this.routes.has(workspaceId));
+        } while (routes.has(workspaceId));
         return workspaceId;
     }
 }
@@ -443,6 +545,62 @@ function stringField(structured, field, label) {
     }
     return value;
 }
+function copyStringField(source, target, field) {
+    const value = source[field];
+    if (typeof value === "string")
+        target[field] = value;
+}
+function copyBooleanField(source, target, field) {
+    const value = source[field];
+    if (typeof value === "boolean")
+        target[field] = value;
+}
+function copyNumberField(source, target, field) {
+    const value = source[field];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+        target[field] = value;
+}
+function safeTaskSummary(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const summary = value;
+    if (summary.level !== "summary" ||
+        summary.version !== 1 ||
+        typeof summary.revision !== "number" ||
+        !Number.isInteger(summary.revision) ||
+        summary.revision < 0 ||
+        !Array.isArray(summary.lists)) {
+        return undefined;
+    }
+    const lists = [];
+    for (const value of summary.lists) {
+        if (!value || typeof value !== "object")
+            return undefined;
+        const list = value;
+        if (typeof list.id !== "string" ||
+            typeof list.name !== "string" ||
+            (list.state !== "active" && list.state !== "archived") ||
+            typeof list.revision !== "number" || !Number.isInteger(list.revision) || list.revision <= 0 ||
+            typeof list.taskCount !== "number" || !Number.isInteger(list.taskCount) || list.taskCount < 0 ||
+            typeof list.unfinishedTaskCount !== "number" || !Number.isInteger(list.unfinishedTaskCount) || list.unfinishedTaskCount < 0) {
+            return undefined;
+        }
+        lists.push({
+            id: list.id,
+            name: list.name,
+            state: list.state,
+            revision: list.revision,
+            taskCount: list.taskCount,
+            unfinishedTaskCount: list.unfinishedTaskCount,
+        });
+    }
+    return {
+        level: "summary",
+        version: 1,
+        revision: summary.revision,
+        lists,
+    };
+}
 function toolResultText(result) {
     return (result.content ?? [])
         .filter((entry) => entry.type === "text")