@akira-tl/forgerelay 0.8.8 → 0.8.9

package/dist/{user-config.js → runtime/config/user-config.js}

@@ -1,13 +1,10 @@
 import { randomBytes, randomUUID } from "node:crypto";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
-import { expandHomePath } from "./roots.js";
-import { mergeHookConfigs, parseHookFile, } from "./hooks.js";
-const AUTH_LOCK_RETRY_MS = 10;
-const AUTH_LOCK_TIMEOUT_MS = 5_000;
-const AUTH_LOCK_STALE_MS = 30_000;
-const AUTH_LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+import { withFileLock } from "../state/lock/file-lock.js";
+import { expandHomePath } from "../../mcp/filesystem/roots.js";
+import { mergeHookConfigs, parseHookFile, } from "../../mcp/hooks/hooks.js";
 export function forgerelayConfigDir(env = process.env) {
     const explicit = env.FORGERELAY_CONFIG_DIR;
     if (explicit)
@@ -60,10 +57,10 @@ export function writeForgeRelayConfig(config, env = process.env) {
     writeJsonFile(filePath, config, 0o600);
     return filePath;
 }
-export function writeForgeRelayAuth(auth, env = process.env) {
+export async function writeForgeRelayAuth(auth, env = process.env) {
     const filePath = forgerelayAuthPath(env);
     mkdirSync(forgerelayConfigDir(env), { recursive: true });
-    return withAuthFileLock(filePath, () => {
+    return withFileLock(`${filePath}.lock`, () => {
         writeJsonFile(filePath, auth, 0o600);
         return filePath;
     });
@@ -74,12 +71,12 @@ export function generateOwnerToken() {
 export function generateInstanceId() {
     return `forge-${randomUUID()}`;
 }
-export function ensureForgeRelayInstanceId(env = process.env) {
+export async function ensureForgeRelayInstanceId(env = process.env) {
     const existing = loadForgeRelayFiles(env).auth.instanceId?.trim();
     if (existing)
         return existing;
     let resolved = "";
-    updateForgeRelayAuth((auth) => {
+    await updateForgeRelayAuth((auth) => {
         const current = auth.instanceId?.trim();
         if (current) {
             resolved = current;
@@ -97,7 +94,7 @@ function normalizeRemoteAlias(alias) {
     }
     return normalized;
 }
-export function writeForgeRelayRemote(alias, remote, env = process.env) {
+export async function writeForgeRelayRemote(alias, remote, env = process.env) {
     const normalizedAlias = normalizeRemoteAlias(alias);
     return updateForgeRelayAuth((auth) => {
         const remotes = { ...(auth.remotes ?? {}) };
@@ -113,7 +110,7 @@ export function writeForgeRelayRemote(alias, remote, env = process.env) {
         return { ...auth, remotes };
     }, env);
 }
-export function renameForgeRelayRemote(fromAlias, toAlias, env = process.env) {
+export async function renameForgeRelayRemote(fromAlias, toAlias, env = process.env) {
     const from = normalizeRemoteAlias(fromAlias);
     const to = normalizeRemoteAlias(toAlias);
     return updateForgeRelayAuth((auth) => {
@@ -128,7 +125,7 @@ export function renameForgeRelayRemote(fromAlias, toAlias, env = process.env) {
         return { ...auth, remotes };
     }, env);
 }
-export function removeForgeRelayRemote(alias, env = process.env) {
+export async function removeForgeRelayRemote(alias, env = process.env) {
     const normalizedAlias = normalizeRemoteAlias(alias);
     return updateForgeRelayAuth((auth) => {
         const remotes = { ...(auth.remotes ?? {}) };
@@ -142,7 +139,7 @@ export function ensureForgeRelayDefaultSkills(env = process.env) {
     const targetPath = join(forgerelaySkillsDir(env), "subagent-delegation", "SKILL.md");
     if (existsSync(targetPath))
         return [];
-    const sourcePath = new URL("../skills/subagent-delegation/SKILL.md", import.meta.url);
+    const sourcePath = new URL("../../../skills/subagent-delegation/SKILL.md", import.meta.url);
     mkdirSync(dirname(targetPath), { recursive: true });
     writeFileSync(targetPath, readFileSync(sourcePath, "utf8"), { mode: 0o644 });
     return [targetPath];
@@ -181,52 +178,15 @@ function readJsonFile(filePath) {
         throw new Error(`Unable to read ${filePath}: ${reason}`);
     }
 }
-function updateForgeRelayAuth(update, env) {
+async function updateForgeRelayAuth(update, env) {
     const filePath = forgerelayAuthPath(env);
     mkdirSync(forgerelayConfigDir(env), { recursive: true });
-    return withAuthFileLock(filePath, () => {
+    return withFileLock(`${filePath}.lock`, () => {
         const auth = existsSync(filePath) ? readJsonFile(filePath) : {};
         writeJsonFile(filePath, update(auth), 0o600);
         return filePath;
     });
 }
-function withAuthFileLock(filePath, operation) {
-    const lockPath = `${filePath}.lock`;
-    const deadline = Date.now() + AUTH_LOCK_TIMEOUT_MS;
-    for (;;) {
-        try {
-            const fd = openSync(lockPath, "wx", 0o600);
-            closeSync(fd);
-            break;
-        }
-        catch (error) {
-            const code = error.code;
-            if (code !== "EEXIST")
-                throw error;
-            try {
-                if (Date.now() - statSync(lockPath).mtimeMs > AUTH_LOCK_STALE_MS) {
-                    rmSync(lockPath, { force: true });
-                    continue;
-                }
-            }
-            catch (statError) {
-                if (statError.code === "ENOENT")
-                    continue;
-                throw statError;
-            }
-            if (Date.now() >= deadline) {
-                throw new Error(`Timed out waiting for ForgeRelay auth lock: ${lockPath}`);
-            }
-            Atomics.wait(AUTH_LOCK_SLEEP, 0, 0, AUTH_LOCK_RETRY_MS);
-        }
-    }
-    try {
-        return operation();
-    }
-    finally {
-        rmSync(lockPath, { force: true });
-    }
-}
 function writeJsonFile(filePath, value, mode) {
     const tempPath = `${filePath}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
     try {

package/dist/{db → runtime/state/db}/client.js

@@ -5,7 +5,7 @@ import { drizzle } from "drizzle-orm/better-sqlite3";
 import * as schema from "./schema.js";
 import { migrateDatabase } from "./migrations.js";
 export function databasePath(stateDir) {
-    return join(stateDir, "devspace.sqlite");
+    return join(stateDir, "forgerelay.sqlite");
 }
 export function openDatabase(stateDir) {
     mkdirSync(stateDir, { recursive: true, mode: 0o700 });

package/dist/{db → runtime/state/db}/migrations.js

@@ -84,18 +84,28 @@ const migrations = [
         name: "workspace-context-components",
         up: migrateWorkspaceContextComponents,
     },
+    {
+        version: 18,
+        name: "file-backed-activity-audit",
+        up: migrateFileBackedActivityAudit,
+    },
+    {
+        version: 19,
+        name: "file-backed-bash-metadata",
+        up: migrateFileBackedBashMetadata,
+    },
 ];
 export function migrateDatabase(sqlite) {
     const migrate = sqlite.transaction(() => {
         sqlite.exec(`
-      create table if not exists devspace_schema_migrations (
+      create table if not exists forgerelay_schema_migrations (
         version integer primary key,
         name text not null,
         applied_at text not null
       );
     `);
-        const applied = new Set(sqlite.prepare("select version from devspace_schema_migrations").all().map((row) => row.version));
-        const recordMigration = sqlite.prepare("insert into devspace_schema_migrations (version, name, applied_at) values (?, ?, ?)");
+        const applied = new Set(sqlite.prepare("select version from forgerelay_schema_migrations").all().map((row) => row.version));
+        const recordMigration = sqlite.prepare("insert into forgerelay_schema_migrations (version, name, applied_at) values (?, ?, ?)");
         for (const migration of migrations) {
             if (applied.has(migration.version))
                 continue;
@@ -418,6 +428,27 @@ function migrateActivityHostTurnWorkspace(sqlite) {
       on activity_host_turns(conversation_scope_id, workspace_id, created_at desc);
   `);
 }
+function migrateFileBackedActivityAudit(sqlite) {
+    if (tableExists(sqlite, "activity_audit_events")) {
+        addColumnIfMissing(sqlite, "activity_audit_events", "payload_file", "text");
+        addColumnIfMissing(sqlite, "activity_audit_events", "payload_offset", "integer");
+        addColumnIfMissing(sqlite, "activity_audit_events", "payload_length", "integer");
+    }
+    if (tableExists(sqlite, "bash_output_streams")) {
+        addColumnIfMissing(sqlite, "bash_output_streams", "log_file", "text");
+        addColumnIfMissing(sqlite, "bash_output_streams", "output_bytes", "integer not null default 0");
+    }
+}
+function migrateFileBackedBashMetadata(sqlite) {
+    if (!tableExists(sqlite, "bash_output_streams"))
+        return;
+    addColumnIfMissing(sqlite, "bash_output_streams", "command_file", "text");
+    addColumnIfMissing(sqlite, "bash_output_streams", "command_offset", "integer");
+    addColumnIfMissing(sqlite, "bash_output_streams", "command_length", "integer");
+    addColumnIfMissing(sqlite, "bash_output_streams", "error_file", "text");
+    addColumnIfMissing(sqlite, "bash_output_streams", "error_offset", "integer");
+    addColumnIfMissing(sqlite, "bash_output_streams", "error_length", "integer");
+}
 function tableExists(sqlite, table) {
     return Boolean(sqlite.prepare("select 1 from sqlite_master where type = 'table' and name = ?").get(table));
 }

package/dist/runtime/state/lock/file-lock.js

@@ -0,0 +1,130 @@
+import { randomBytes } from "node:crypto";
+import { open, readFile, rename, rm, stat } from "node:fs/promises";
+const DEFAULT_RETRY_MS = 10;
+const DEFAULT_TIMEOUT_MS = 5_000;
+const DEFAULT_STALE_MS = 30_000;
+/**
+ * Cross-process lock acquisition must yield the event loop: these locks guard
+ * tiny JSON state updates, but a contended lock can otherwise freeze every MCP
+ * request handled by the same Node process. The owner token also prevents a
+ * process that lost an abandoned lock from deleting a later owner's lock when
+ * it eventually reaches cleanup.
+ */
+export async function withFileLock(lockPath, operation, options = {}) {
+    const retryMs = positiveInteger(options.retryMs, DEFAULT_RETRY_MS, "retryMs");
+    const timeoutMs = positiveInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS, "timeoutMs");
+    const staleMs = positiveInteger(options.staleMs, DEFAULT_STALE_MS, "staleMs");
+    const mode = options.mode ?? 0o600;
+    const owner = {
+        pid: process.pid,
+        token: randomBytes(16).toString("hex"),
+    };
+    const serializedOwner = `${JSON.stringify(owner)}\n`;
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        try {
+            const handle = await open(lockPath, "wx", mode);
+            try {
+                await handle.writeFile(serializedOwner, "utf8");
+            }
+            finally {
+                await handle.close();
+            }
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+        }
+        if (await reclaimAbandonedLock(lockPath, staleMs))
+            continue;
+        if (Date.now() >= deadline) {
+            throw new Error(`Timed out waiting for file lock: ${lockPath}`);
+        }
+        await delay(Math.min(retryMs, Math.max(1, deadline - Date.now())));
+    }
+    try {
+        return await operation();
+    }
+    finally {
+        await releaseOwnedLock(lockPath, owner);
+    }
+}
+async function reclaimAbandonedLock(lockPath, staleMs) {
+    let owner;
+    let ageMs;
+    try {
+        const [contents, info] = await Promise.all([
+            readFile(lockPath, "utf8"),
+            stat(lockPath),
+        ]);
+        owner = parseOwner(contents);
+        ageMs = Date.now() - info.mtimeMs;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    // A valid live PID is stronger evidence than mtime. This avoids declaring a
+    // long but healthy operation stale merely because the event loop was paused.
+    if (owner && processIsAlive(owner.pid))
+        return false;
+    if (!owner && ageMs <= staleMs)
+        return false;
+    const stalePath = `${lockPath}.${process.pid}.${randomBytes(8).toString("hex")}.stale`;
+    try {
+        await rename(lockPath, stalePath);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return true;
+        throw error;
+    }
+    await rm(stalePath, { force: true });
+    return true;
+}
+async function releaseOwnedLock(lockPath, owner) {
+    let current;
+    try {
+        current = parseOwner(await readFile(lockPath, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    if (!current || current.pid !== owner.pid || current.token !== owner.token)
+        return;
+    await rm(lockPath, { force: true });
+}
+function parseOwner(contents) {
+    try {
+        const value = JSON.parse(contents);
+        return Number.isSafeInteger(value.pid) && (value.pid ?? 0) > 0 && typeof value.token === "string" && value.token
+            ? { pid: value.pid, token: value.token }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+function positiveInteger(value, fallback, name) {
+    const resolved = value ?? fallback;
+    if (!Number.isSafeInteger(resolved) || resolved <= 0) {
+        throw new Error(`File lock ${name} must be a positive integer.`);
+    }
+    return resolved;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/runtime/testing/server-fixture.js

@@ -0,0 +1,190 @@
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.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 "../config/config.js";
+import { parseHookConfig } from "../../mcp/hooks/hooks.js";
+import { CodeIntelligenceManager } from "../../lsp/runtime/manager.js";
+import { ProcessManager } from "../../mcp/process/process-sessions.js";
+import { createReviewCheckpointManager } from "../../workspaces/review/review-checkpoints.js";
+import { createMcpServer } from "../../server.js";
+import { SqliteWorkspaceStore } from "../../workspaces/state/workspace-store.js";
+import { WorkspaceRegistry } from "../../workspaces.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Build the real in-memory MCP seam used by server integration tests. The
+ * fixture owns all durable stores and runtime managers so tests exercise the
+ * same composition path while keeping filesystem state isolated per test.
+ */
+export async function fixture(t, options = {}) {
+    const root = await mkdtemp(join(tmpdir(), "forgerelay-server-test-"));
+    const project = join(root, "project");
+    const agentDir = join(root, "agent");
+    const stateDir = join(root, ".state");
+    await mkdir(join(project, ".forgerelay", "agents"), { recursive: true });
+    await mkdir(agentDir, { recursive: true });
+    await writeFile(join(agentDir, "AGENTS.md"), "global instructions\n");
+    await writeFile(join(project, "AGENTS.md"), "project instructions\n");
+    await writeFile(join(project, ".forgerelay", "agents", "reviewer.md"), [
+        "---",
+        "name: reviewer",
+        "description: Reviews project changes.",
+        "provider: codex",
+        "---",
+        "Review changes.",
+    ].join("\n"));
+    if (options.git) {
+        await writeFile(join(project, "README.md"), "hello\n");
+        await git(project, ["init"]);
+        await git(project, ["config", "user.email", "forgerelay@example.com"]);
+        await git(project, ["config", "user.name", "ForgeRelay Test"]);
+        await git(project, ["add", "."]);
+        await git(project, ["commit", "-m", "Initial commit"]);
+    }
+    const loadedConfig = loadConfig({
+        FORGERELAY_CONFIG_DIR: join(root, ".config"),
+        FORGERELAY_STATE_DIR: stateDir,
+        FORGERELAY_ALLOWED_ROOTS: root,
+        FORGERELAY_WORKTREE_ROOT: join(root, ".worktrees"),
+        FORGERELAY_AGENT_DIR: agentDir,
+        FORGERELAY_WIDGETS: "full",
+        FORGERELAY_TOOL_MODE: "full",
+        FORGERELAY_OAUTH_OWNER_TOKEN: "test-owner-token-that-is-long-enough",
+        PORT: "1",
+        ...options.env,
+    });
+    const config = options.hooks
+        ? { ...loadedConfig, hooks: parseHookConfig(options.hooks) }
+        : loadedConfig;
+    const store = new SqliteWorkspaceStore(stateDir);
+    const workspaces = new WorkspaceRegistry(config, store);
+    const auditStore = new ActivityAuditStore(stateDir);
+    const bashOutputStore = new BashOutputStore(stateDir);
+    let hostTurnSequence = 0;
+    const hostTurnStore = new HostTurnStore(stateDir, {
+        turnId: () => `turn_host_test_${++hostTurnSequence}`,
+    });
+    const activityQueries = new ActivityQueryService(hostTurnStore, auditStore, bashOutputStore);
+    const processSessions = options.processSessions ?? new ProcessManager({ outputAudit: bashOutputStore });
+    let activitySequence = 0;
+    let turnSequence = 0;
+    const activityLifecycle = new ActivityLifecycle(auditStore, {
+        activityId: () => `act_test_${++activitySequence}`,
+        turnId: () => `turn_test_${++turnSequence}`,
+        turnIdForConversation: (conversationScopeId, workspaceId) => activityQueries.currentTurnId(conversationScopeId, workspaceId),
+    });
+    const codeIntelligence = new CodeIntelligenceManager(config);
+    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], options.incomingArtifactAdapters ?? [], codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const client = new Client({ name: "forgerelay-test-client", version: "1.0.0" });
+    await Promise.all([
+        client.connect(clientTransport),
+        server.connect(serverTransport),
+    ]);
+    let closed = false;
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        await client.close();
+        await server.close();
+        await codeIntelligence.shutdown();
+        processSessions.shutdown();
+        hostTurnStore.close();
+        bashOutputStore.close();
+        auditStore.close();
+        store.close();
+    };
+    t.after(async () => {
+        await close();
+        await rm(root, { recursive: true, force: true });
+    });
+    return {
+        client,
+        project,
+        config,
+        stateDir,
+        store,
+        workspaces,
+        processSessions,
+        activityLifecycle,
+        codeIntelligence,
+        auditStore,
+        bashOutputStore,
+        hostTurnStore,
+        activityQueries,
+        close,
+    };
+}
+export async function git(cwd, args) {
+    await execFileAsync("git", args, { cwd });
+}
+export async function callOpen(client, path, conversationScopeId, mode, newWorktree) {
+    const params = {
+        name: "open_workspace",
+        arguments: {
+            path,
+            ...(mode ? { mode } : {}),
+            ...(newWorktree ? { newWorktree: true } : {}),
+        },
+        ...(conversationScopeId
+            ? { _meta: { "openai/session": conversationScopeId } }
+            : {}),
+    };
+    return client.callTool(params);
+}
+export function structuredContent(result) {
+    assert.ok(result.structuredContent);
+    return result.structuredContent;
+}
+export function responseText(result) {
+    const content = result.content;
+    assert.ok(Array.isArray(content));
+    const first = content[0];
+    assert.equal(first?.type, "text");
+    assert.equal(typeof first?.text, "string");
+    return first?.text;
+}
+export function allResponseText(result) {
+    const content = result.content;
+    assert.ok(Array.isArray(content));
+    return content
+        .filter((entry) => typeof entry === "object" &&
+        entry !== null &&
+        entry.type === "text" &&
+        typeof entry.text === "string")
+        .map((entry) => entry.text)
+        .join("\n");
+}
+export async function waitForCompletedProcess(processSessions) {
+    const deadline = performance.now() + 5_000;
+    while (processSessions.stats().completed === 0 && performance.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    assert.equal(processSessions.stats().completed, 1);
+}
+export async function waitForToolText(client, params, expected, timeoutMs = 5_000) {
+    const deadline = performance.now() + timeoutMs;
+    let result = await client.callTool(params);
+    while (!expected.test(allResponseText(result)) && performance.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 25));
+        result = await client.callTool(params);
+    }
+    return result;
+}
+export function responseCard(result) {
+    const metadata = result._meta;
+    assert.ok(metadata && typeof metadata === "object");
+    const card = metadata.card;
+    assert.ok(card && typeof card === "object");
+    return card;
+}