@akira-tl/forgerelay 0.8.7 → 0.8.9

package/dist/workspaces/inventory.js

@@ -0,0 +1,131 @@
+import { basename, resolve } from "node:path";
+import { assertAllowedPath } from "../mcp/filesystem/roots.js";
+import { canonicalPath } from "./paths.js";
+const WORKSPACE_STALE_REMINDER_MS = 2 * 24 * 60 * 60 * 1_000;
+/** Build bounded read-only projections over persistent Workspace sessions. */
+export class WorkspaceInventoryService {
+    config;
+    store;
+    workspaces;
+    sessions;
+    constructor(config, store, workspaces, sessions) {
+        this.config = config;
+        this.store = store;
+        this.workspaces = workspaces;
+        this.sessions = sessions;
+    }
+    async inspectWorkspace(workspaceId) {
+        let session = this.store?.getSession(workspaceId);
+        if (!session) {
+            const workspace = this.workspaces.get(workspaceId);
+            if (workspace)
+                session = workspaceSessionSnapshot(workspace);
+        }
+        if (!session)
+            throw new Error(`Unknown workspaceId: ${workspaceId}.`);
+        const entry = await this.inventoryEntryForSession(session, Date.now(), false);
+        const { current: _current, ...inspection } = entry;
+        return { kind: "workspace", location: "local", ...inspection };
+    }
+    async listWorkspaces(input = {}, openOptions = {}) {
+        this.sessions.pruneIdleWorkspaceSessions(openOptions.protectedWorkspaceIds ?? new Set());
+        const now = Date.now();
+        const sessions = this.store
+            ? this.store.listSessions()
+            : [...this.workspaces.values()].map(workspaceSessionSnapshot);
+        const currentWorkspaceIds = new Set(openOptions.conversationScopeId && this.store
+            ? this.store
+                .listConversationBindings()
+                .filter((binding) => binding.conversationScopeId === openOptions.conversationScopeId)
+                .map((binding) => binding.workspaceSessionId)
+            : []);
+        const workspaceIdFilter = input.workspaceId
+            ? this.store?.getSession(input.workspaceId)?.id ?? input.workspaceId
+            : undefined;
+        const rootKey = input.root
+            ? await canonicalPath(assertAllowedPath(input.root, [...this.config.allowedRoots, this.config.worktreeRoot]))
+            : undefined;
+        const entries = await Promise.all(sessions.map((session) => this.inventoryEntryForSession(session, now, currentWorkspaceIds.has(session.id))));
+        const filtered = [];
+        for (let index = 0; index < sessions.length; index += 1) {
+            const session = sessions[index];
+            const entry = entries[index];
+            if (!session || !entry)
+                continue;
+            if (workspaceIdFilter && entry.workspaceId !== workspaceIdFilter)
+                continue;
+            if (input.status && entry.status !== input.status)
+                continue;
+            if (input.state && entry.state !== input.state)
+                continue;
+            if (input.mode && entry.mode !== input.mode)
+                continue;
+            if (input.staleOnly && entry.state !== "stale")
+                continue;
+            if (rootKey) {
+                const sessionRootKey = await canonicalPath(session.root);
+                const sourceRootKey = session.sourceRoot ? await canonicalPath(session.sourceRoot) : undefined;
+                if (sessionRootKey !== rootKey && sourceRootKey !== rootKey)
+                    continue;
+            }
+            filtered.push(entry);
+        }
+        const summary = filtered.reduce((counts, entry) => {
+            counts[entry.state] += 1;
+            return counts;
+        }, { active: 0, stale: 0, invalid: 0, closed: 0 });
+        const offset = Math.max(0, input.offset ?? 0);
+        const limit = Math.min(100, Math.max(1, input.limit ?? 50));
+        return {
+            workspaces: filtered.slice(offset, offset + limit),
+            summary: { total: entries.length, matching: filtered.length, ...summary },
+            page: { offset, limit, hasMore: offset + limit < filtered.length },
+        };
+    }
+    async inventoryEntryForSession(session, now, current) {
+        const rootValid = await this.sessions.validSessionRoot(session) !== undefined;
+        const lastUsedAt = Date.parse(session.lastUsedAt);
+        const idleMs = Number.isFinite(lastUsedAt) ? Math.max(0, now - lastUsedAt) : 0;
+        const state = session.status !== "active"
+            ? "closed"
+            : !rootValid
+                ? "invalid"
+                : idleMs >= WORKSPACE_STALE_REMINDER_MS
+                    ? "stale"
+                    : "active";
+        const projectRoot = session.sourceRoot ?? session.root;
+        return {
+            label: `${basename(resolve(projectRoot)) || "workspace"}/${session.id}`,
+            workspaceId: session.id,
+            root: session.root,
+            status: session.status,
+            state,
+            mode: session.mode,
+            sourceRoot: session.sourceRoot,
+            branch: session.branch,
+            targetBranch: session.targetBranch,
+            managed: session.managed,
+            createdAt: session.createdAt,
+            lastUsedAt: session.lastUsedAt,
+            idleMs,
+            rootValid,
+            current,
+        };
+    }
+}
+function workspaceSessionSnapshot(workspace) {
+    return {
+        id: workspace.id,
+        root: workspace.root,
+        status: "active",
+        mode: workspace.mode,
+        sourceRoot: workspace.sourceRoot,
+        baseRef: workspace.worktree?.baseRef,
+        baseSha: workspace.worktree?.baseSha,
+        branch: workspace.worktree?.branch,
+        targetBranch: workspace.worktree?.targetBranch,
+        managed: workspace.worktree?.managed ?? false,
+        createdAt: "",
+        lastUsedAt: "",
+    };
+}

package/dist/workspaces/paths.js

@@ -0,0 +1,55 @@
+import { realpathSync } from "node:fs";
+import { mkdir, realpath, stat } from "node:fs/promises";
+import { basename, dirname, resolve } from "node:path";
+export function canonicalPersistedWorkspacePath(path) {
+    const missingSegments = [];
+    let candidate = path;
+    while (true) {
+        try {
+            return resolve(realpathSync(candidate), ...missingSegments.slice().reverse());
+        }
+        catch (error) {
+            if (!isErrnoException(error) || (error.code !== "ENOENT" && error.code !== "ENOTDIR")) {
+                return resolve(path);
+            }
+            const parent = dirname(candidate);
+            if (parent === candidate)
+                return resolve(path);
+            missingSegments.push(basename(candidate));
+            candidate = parent;
+        }
+    }
+}
+export async function canonicalPath(path) {
+    const missingSegments = [];
+    let candidate = path;
+    while (true) {
+        try {
+            return resolve(await realpath(candidate), ...missingSegments.slice().reverse());
+        }
+        catch (error) {
+            if (!isErrnoException(error) || (error.code !== "ENOENT" && error.code !== "ENOTDIR")) {
+                throw error;
+            }
+            const parent = dirname(candidate);
+            if (parent === candidate)
+                return path;
+            missingSegments.push(basename(candidate));
+            candidate = parent;
+        }
+    }
+}
+export async function ensureCheckoutWorkspaceRoot(path, ops = { stat, mkdir }) {
+    try {
+        return await ops.stat(path);
+    }
+    catch (error) {
+        if (!isErrnoException(error) || error.code !== "ENOENT")
+            throw error;
+    }
+    await ops.mkdir(path, { recursive: true });
+    return await ops.stat(path);
+}
+function isErrnoException(error) {
+    return error instanceof Error && "code" in error;
+}

package/dist/{remote-auth.js → workspaces/relay/auth/remote-auth.js}

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs";
 import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StreamableHTTPClientTransport, StreamableHTTPError, } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { publicEndpointUrl } from "./oauth/public-url.js";
+import { publicEndpointUrl } from "../../../mcp/oauth/public-url.js";
 const REMOTE_AUTH_TIMEOUT_MS = 15_000;
 const packageVersion = readForgeRelayVersion();
 export function normalizeRemoteServiceTarget(value) {
@@ -112,7 +112,7 @@ async function exchangeCliCredential(target, credential) {
     };
 }
 function readForgeRelayVersion() {
-    const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    const packageJson = JSON.parse(readFileSync(new URL("../../../../package.json", import.meta.url), "utf8"));
     if (typeof packageJson.version !== "string" || packageJson.version.length === 0) {
         throw new Error("Unable to read ForgeRelay package version.");
     }

package/dist/workspaces/relay/result-support.js

@@ -0,0 +1,111 @@
+export function assertRemoteToolSucceeded(alias, tool, result) {
+    if (result.isError !== true)
+        return;
+    throw new Error(`Remote ForgeRelay ${alias} ${tool} failed: ${toolResultText(result)}`);
+}
+export function stringField(structured, field, label) {
+    const value = structured?.[field];
+    if (typeof value !== "string" || !value) {
+        throw new Error(`${label} did not include ${field}.`);
+    }
+    return value;
+}
+export function copyStringField(source, target, field) {
+    const value = source[field];
+    if (typeof value === "string")
+        target[field] = value;
+}
+export function copyBooleanField(source, target, field) {
+    const value = source[field];
+    if (typeof value === "boolean")
+        target[field] = value;
+}
+export function copyNumberField(source, target, field) {
+    const value = source[field];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+        target[field] = value;
+}
+export 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,
+    };
+}
+export function toolResultText(result) {
+    return (result.content ?? [])
+        .filter((entry) => entry.type === "text")
+        .map((entry) => entry.text)
+        .join("\n") || "remote tool returned an error";
+}
+export function remapToolResultWorkspaceId(result, remoteWorkspaceId, gatewayWorkspaceId) {
+    return {
+        ...result,
+        content: (result.content ?? []).map((entry) => entry.type === "text"
+            ? { ...entry, text: entry.text.split(remoteWorkspaceId).join(gatewayWorkspaceId) }
+            : entry),
+        ...(result._meta
+            ? { _meta: replaceExactWorkspaceId(result._meta, remoteWorkspaceId, gatewayWorkspaceId) }
+            : {}),
+        ...(result.structuredContent
+            ? {
+                structuredContent: replaceExactWorkspaceId(result.structuredContent, remoteWorkspaceId, gatewayWorkspaceId),
+            }
+            : {}),
+    };
+}
+export function replaceExactWorkspaceId(value, from, to) {
+    if (typeof value === "string")
+        return value.split(from).join(to);
+    if (Array.isArray(value))
+        return value.map((entry) => replaceExactWorkspaceId(entry, from, to));
+    if (!value || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .map(([key, entry]) => [key, replaceExactWorkspaceId(entry, from, to)]));
+}
+export function sanitizedRemoteError(error, remoteWorkspaceId, gatewayWorkspaceId) {
+    let message = errorMessage(error);
+    if (remoteWorkspaceId && gatewayWorkspaceId) {
+        message = message.split(remoteWorkspaceId).join(gatewayWorkspaceId);
+    }
+    message = message.replace(/(^|[^A-Za-z0-9_])ws_[0-9a-f]{10}(?=$|[^A-Za-z0-9_])/g, "$1[remote-workspace]");
+    return new Error(message, { cause: error });
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/workspaces/relay/tests/test-support.js

@@ -0,0 +1,203 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { createRequire, syncBuiltinESMExports } from "node:module";
+import { join } from "node:path";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
+import { ActivityAuditStore } from "../../../activity/history/audit-store.js";
+import { BashOutputStore } from "../../../activity/history/bash-output-store.js";
+import { HostTurnStore } from "../../../activity/history/host-turn-store.js";
+import { ActivityLifecycle } from "../../../activity/runtime/lifecycle.js";
+import { ActivityQueryService } from "../../../activity/history/query-service.js";
+import { loadConfig } from "../../../runtime/config/config.js";
+import { CodeIntelligenceManager } from "../../../lsp/runtime/manager.js";
+import { createReviewCheckpointManager } from "../../review/review-checkpoints.js";
+import { ProcessManager } from "../../../mcp/process/process-sessions.js";
+import { createMcpServer, createServer } from "../../../server.js";
+import { SqliteWorkspaceStore } from "../../state/workspace-store.js";
+import { WorkspaceRegistry } from "../../../workspaces.js";
+const childProcessModule = createRequire(import.meta.url)("node:child_process");
+const cleanProductEnv = Object.fromEntries(Object.entries(process.env).filter(([name]) => !name.startsWith("FORGERELAY_")));
+export async function setupGitRepository(root) {
+    await mkdir(root, { recursive: true });
+    execFileSync("git", ["init", "-b", "main"], { cwd: root, stdio: "ignore" });
+    execFileSync("git", ["config", "user.name", "ForgeRelay Test"], { cwd: root });
+    execFileSync("git", ["config", "user.email", "forgerelay-test@example.invalid"], { cwd: root });
+    await writeFile(join(root, "README.md"), "relay worktree fixture\n");
+    execFileSync("git", ["add", "README.md"], { cwd: root });
+    execFileSync("git", ["commit", "-m", "TEST: (relay) initialize worktree fixture"], { cwd: root, stdio: "ignore" });
+}
+export async function startForge(t, options) {
+    const configDir = options.existingConfigDir ?? join(options.root, "config");
+    const stateDir = join(options.root, "state");
+    await mkdir(configDir, { recursive: true });
+    await mkdir(stateDir, { recursive: true });
+    if (!options.existingConfigDir) {
+        await writeFile(join(configDir, "auth.json"), JSON.stringify({
+            ownerToken: options.ownerToken,
+            instanceId: options.instanceId,
+        }, null, 2), { mode: 0o600 });
+    }
+    await writeFile(join(configDir, "config.json"), JSON.stringify({
+        host: "127.0.0.1",
+        port: 7676,
+        allowedRoots: [options.allowedRoot],
+        publicBaseUrl: "http://127.0.0.1:7676",
+        stateDir,
+        worktreeRoot: join(options.root, "worktrees"),
+        ...(options.taskReminderInterval !== undefined ? { taskReminderInterval: options.taskReminderInterval } : {}),
+        ...(options.hooks ? { hooks: options.hooks } : {}),
+    }, null, 2));
+    const env = {
+        ...cleanProductEnv,
+        FORGERELAY_CONFIG_DIR: configDir,
+        FORGERELAY_TOOL_MODE: options.toolMode ?? "minimal",
+        FORGERELAY_WIDGETS: "off",
+        FORGERELAY_SKILLS: "0",
+    };
+    const running = createServer(loadConfig(env));
+    const httpServer = running.app.listen(0, "127.0.0.1");
+    await new Promise((resolve) => httpServer.once("listening", resolve));
+    const port = httpServer.address().port;
+    t.after(async () => {
+        await running.close();
+        await new Promise((resolve) => httpServer.close(() => resolve()));
+    });
+    return {
+        endpoint: `http://127.0.0.1:${port}`,
+        ownerToken: options.ownerToken,
+        openAdditionalEndpoint: async () => {
+            const additionalServer = running.app.listen(0, "127.0.0.1");
+            await new Promise((resolve) => additionalServer.once("listening", resolve));
+            const additionalPort = additionalServer.address().port;
+            t.after(() => new Promise((resolve) => additionalServer.close(() => resolve())));
+            return `http://127.0.0.1:${additionalPort}`;
+        },
+    };
+}
+export async function startGatewayClient(t, options) {
+    const stateDir = options.stateDir ?? join(options.root, "state");
+    await mkdir(stateDir, { recursive: true });
+    await writeFile(join(options.configDir, "config.json"), JSON.stringify({
+        allowedRoots: [options.allowedRoot],
+        stateDir,
+        ...(options.hooks ? { hooks: options.hooks } : {}),
+    }, null, 2));
+    const config = loadConfig({
+        ...cleanProductEnv,
+        FORGERELAY_CONFIG_DIR: options.configDir,
+        FORGERELAY_TOOL_MODE: options.toolMode ?? "minimal",
+        FORGERELAY_WIDGETS: "off",
+        FORGERELAY_SKILLS: "0",
+    });
+    const workspaceStore = new SqliteWorkspaceStore(stateDir);
+    const workspaces = new WorkspaceRegistry(config, workspaceStore);
+    const auditStore = new ActivityAuditStore(stateDir);
+    const bashOutputStore = new BashOutputStore(stateDir);
+    const hostTurnStore = new HostTurnStore(stateDir);
+    const activityQueries = new ActivityQueryService(hostTurnStore, auditStore, bashOutputStore);
+    const processSessions = new ProcessManager({ outputAudit: bashOutputStore });
+    const activityLifecycle = new ActivityLifecycle(auditStore, {
+        turnIdForConversation: (conversationScopeId, workspaceId) => activityQueries.currentTurnId(conversationScopeId, workspaceId),
+    });
+    const codeIntelligence = new CodeIntelligenceManager(config);
+    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const client = new Client({ name: "forgerelay-workspace-relay-test", version: "1.0.0" });
+    await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
+    t.after(async () => {
+        await client.close();
+        await server.close();
+        await codeIntelligence.shutdown();
+        processSessions.shutdown();
+        hostTurnStore.close();
+        bashOutputStore.close();
+        auditStore.close();
+        workspaceStore.close();
+    });
+    return client;
+}
+export async function installFakeSsh(t, root, sshLog) {
+    const fakeSshPath = join(root, "fake-ssh.cjs");
+    await writeFile(fakeSshPath, fakeSshRelaySource());
+    const originalSpawn = childProcessModule.spawn;
+    childProcessModule.spawn = ((command, args = [], options = {}) => {
+        if (command !== "ssh")
+            return originalSpawn(command, args, options);
+        return originalSpawn(process.execPath, [fakeSshPath, ...args], {
+            ...options,
+            env: {
+                ...process.env,
+                ...(options.env ?? {}),
+                TEST_SSH_LOG: sshLog,
+            },
+        });
+    });
+    syncBuiltinESMExports();
+    t.after(() => {
+        childProcessModule.spawn = originalSpawn;
+        syncBuiltinESMExports();
+    });
+}
+function fakeSshRelaySource() {
+    return `#!/usr/bin/env node
+const fs = require("node:fs");
+const net = require("node:net");
+const args = process.argv.slice(2);
+fs.appendFileSync(process.env.TEST_SSH_LOG, JSON.stringify(args) + "\\n");
+const forwardIndex = args.indexOf("-L");
+const forward = forwardIndex >= 0 ? args[forwardIndex + 1] : undefined;
+if (!forward) {
+  process.stderr.write("fake ssh: missing -L\\n");
+  process.exit(40);
+}
+const match = /^127\\.0\\.0\\.1:(\\d+):([^:]+):(\\d+)$/.exec(forward);
+if (!match) {
+  process.stderr.write("fake ssh: invalid forward " + forward + "\\n");
+  process.exit(41);
+}
+const localPort = Number(match[1]);
+const remoteHost = match[2];
+const remotePort = Number(match[3]);
+const sockets = new Set();
+const server = net.createServer((client) => {
+  const upstream = net.connect(remotePort, remoteHost);
+  sockets.add(client);
+  sockets.add(upstream);
+  client.on("close", () => sockets.delete(client));
+  upstream.on("close", () => sockets.delete(upstream));
+  client.pipe(upstream);
+  upstream.pipe(client);
+});
+server.on("error", (error) => {
+  process.stderr.write(String(error) + "\\n");
+  process.exit(42);
+});
+server.listen(localPort, "127.0.0.1", () => {
+  process.stderr.write("debug1: Local forwarding listening on 127.0.0.1 port " + localPort + ".\\n");
+});
+const stop = () => {
+  for (const socket of sockets) socket.destroy();
+  server.close(() => process.exit(0));
+};
+process.on("SIGTERM", stop);
+process.on("SIGINT", stop);
+`;
+}
+export function structuredContent(result) {
+    const parsed = parseToolResult(result);
+    assert.ok(parsed.structuredContent);
+    return parsed.structuredContent;
+}
+export function resultText(result) {
+    const parsed = parseToolResult(result);
+    return (parsed.content ?? [])
+        .filter((entry) => entry.type === "text")
+        .map((entry) => entry.text)
+        .join("\n");
+}
+function parseToolResult(result) {
+    return CallToolResultSchema.parse(result);
+}

package/dist/{remote-mcp-connection-pool.js → workspaces/relay/transport/remote-mcp-connection-pool.js}

@@ -1,4 +1,4 @@
-import { connectRemoteMcpClient } from "./remote-auth.js";
+import { connectRemoteMcpClient } from "../auth/remote-auth.js";
 import { openRemoteServiceEndpoint, } from "./remote-transport.js";
 export class RemoteMcpConnectionPool {
     entries = new Map();

package/dist/workspaces/relay/types.js

@@ -0,0 +1 @@
+export {};