@akira-tl/forgerelay 0.8.7 → 0.8.9

package/dist/activity/{query-service.js → history/query-service.js}

@@ -1,3 +1,4 @@
+import { deleteWorkspaceActivityHistory } from "../storage/history.js";
 export class ActivityQueryService {
     turns;
     audit;
@@ -7,6 +8,15 @@ export class ActivityQueryService {
         this.audit = audit;
         this.outputs = outputs;
     }
+    deleteWorkspaceHistory(stateDir, workspaceId) {
+        deleteWorkspaceActivityHistory({
+            stateDir,
+            workspaceId,
+            audit: this.audit,
+            outputs: this.outputs,
+            turns: this.turns,
+        });
+    }
     beginTurn(conversationScopeId, workspaceId) {
         const turn = this.turns.begin(conversationScopeId, workspaceId);
         return this.state(turn.turnId);
@@ -73,7 +83,7 @@ export class ActivityQueryService {
     }
     bashOutput(turnId, outputId, cursor = 0) {
         this.requireTurn(turnId);
-        const output = this.outputs.read(outputId);
+        const output = this.outputs.readSince(outputId, cursor);
         if (!output)
             throw new Error(`Unknown Bash output: ${outputId}.`);
         const activities = this.audit.listActivitiesByTurn(turnId);
@@ -81,17 +91,13 @@ export class ActivityQueryService {
         if (!visible) {
             throw new Error(`Bash output ${outputId} is not part of Host Turn ${turnId}.`);
         }
-        const latestCursor = output.chunks.at(-1)?.sequence ?? 0;
         return {
             outputId: output.outputId,
             activityId: output.activityId,
             processId: output.processId,
             command: output.command,
-            output: output.chunks
-                .filter((chunk) => chunk.sequence > cursor)
-                .map((chunk) => chunk.data)
-                .join(""),
-            cursor: latestCursor,
+            output: output.output,
+            cursor: output.cursor,
             status: output.status,
             ...(output.exitCode !== undefined ? { exitCode: output.exitCode } : {}),
             ...(output.signal !== undefined ? { signal: output.signal } : {}),

package/dist/activity/{lifecycle.js → runtime/lifecycle.js}

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { HookExecutionError } from "../hooks.js";
+import { HookExecutionError } from "../../mcp/hooks/hooks.js";
 export class ActivityLifecycle {
     auditStore;
     activityId;

package/dist/activity/{mcp-query-tools.js → runtime/mcp-query-tools.js}

@@ -1,8 +1,8 @@
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import * as z from "zod/v4";
-import { logEvent, transportSessionIdPrefix } from "../logger.js";
-import { hostConversationScopeId } from "../request-meta.js";
-import { ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY, ACTIVITY_PANEL_WORKSPACE_META_KEY, } from "./ui/contract.js";
+import { logEvent, transportSessionIdPrefix } from "../../runtime/logging/logger.js";
+import { hostConversationScopeId } from "../../mcp/request-meta.js";
+import { ACTIVITY_PANEL_DEFAULT_EXPANDED_META_KEY, ACTIVITY_PANEL_WORKSPACE_META_KEY, } from "../ui/contract.js";
 const READ_ONLY_ANNOTATIONS = {
     readOnlyHint: true,
     destructiveHint: false,

package/dist/activity/storage/history.js

@@ -0,0 +1,12 @@
+import { removeWorkspaceActivityStorage } from "./paths.js";
+/**
+ * User-requested Workspace deletion is the retention boundary for durable
+ * Activity history by default. Index rows are removed before the backing files
+ * so a crash cannot leave SQLite pointing at already-deleted payload shards.
+ */
+export function deleteWorkspaceActivityHistory(input) {
+    input.outputs.deleteWorkspace(input.workspaceId);
+    input.audit.deleteWorkspace(input.workspaceId);
+    input.turns.deleteWorkspace(input.workspaceId);
+    removeWorkspaceActivityStorage(input.stateDir, input.workspaceId);
+}

package/dist/activity/storage/paths.js

@@ -0,0 +1,56 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, rmSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+const SAFE_WORKSPACE_ID = /^(?:ws|rws|cws)_[a-z0-9]+$/i;
+export function activityWorkspaceStorageKey(workspace) {
+    if (workspace.id && SAFE_WORKSPACE_ID.test(workspace.id))
+        return workspace.id;
+    return `root_${createHash("sha256").update(`${workspace.mode}\0${resolve(workspace.root)}`).digest("hex").slice(0, 20)}`;
+}
+export function activityWorkspaceDirectory(stateDir, workspace) {
+    return join(stateDir, "workspaces", activityWorkspaceStorageKey(workspace), "activity");
+}
+export function activityEventLogPrefix(stateDir, workspace) {
+    return join(activityWorkspaceDirectory(stateDir, workspace), "events");
+}
+export function bashOutputDirectory(stateDir, workspace) {
+    return join(activityWorkspaceDirectory(stateDir, workspace), "bash");
+}
+export function bashOutputLogPrefix(stateDir, workspace, outputId) {
+    return join(bashOutputDirectory(stateDir, workspace), outputId);
+}
+export function bashOutputMetadataPrefix(stateDir, workspace, outputId, field) {
+    return join(bashOutputDirectory(stateDir, workspace), `${outputId}-${field}`);
+}
+export function removeWorkspaceActivityStorage(stateDir, workspaceId) {
+    if (!SAFE_WORKSPACE_ID.test(workspaceId)) {
+        throw new Error(`Invalid Workspace id for Activity storage cleanup: ${workspaceId}`);
+    }
+    rmSync(join(stateDir, "workspaces", workspaceId, "activity"), {
+        recursive: true,
+        force: true,
+    });
+}
+export function ensurePrivateDirectory(path) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+}
+export function stateRelativePath(stateDir, path) {
+    const relationship = relative(resolve(stateDir), resolve(path));
+    if (relationship === "" ||
+        relationship === ".." ||
+        relationship.startsWith(`..${sep}`)) {
+        throw new Error(`Activity log path is outside ForgeRelay state directory: ${path}`);
+    }
+    return relationship.split(sep).join("/");
+}
+export function resolveStateRelativePath(stateDir, path) {
+    const absolute = resolve(stateDir, path);
+    const relationship = relative(resolve(stateDir), absolute);
+    if (relationship === ".." || relationship.startsWith(`..${sep}`)) {
+        throw new Error(`Activity log reference escapes ForgeRelay state directory: ${path}`);
+    }
+    return absolute;
+}
+export function ensureParentPrivate(path) {
+    ensurePrivateDirectory(dirname(path));
+}

package/dist/activity/storage/segmented-log.js

@@ -0,0 +1,149 @@
+import { closeSync, constants as fsConstants, fstatSync, openSync, readSync, readdirSync, statSync, writeSync, } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { ensureParentPrivate, resolveStateRelativePath, stateRelativePath } from "./paths.js";
+/**
+ * Segment files are deliberately small enough to inspect, copy, prune, and
+ * recover independently. The logical stream may be arbitrarily large; no
+ * individual on-disk activity/output file should grow without bound.
+ */
+export const ACTIVITY_LOG_SEGMENT_BYTES = 8 * 1024 * 1024;
+export class SegmentedLogStore {
+    stateDir;
+    segmentBytes;
+    appendOffsets = new Map();
+    constructor(stateDir, segmentBytes = ACTIVITY_LOG_SEGMENT_BYTES) {
+        this.stateDir = stateDir;
+        this.segmentBytes = segmentBytes;
+    }
+    append(prefixPath, data) {
+        const prefix = stateRelativePath(this.stateDir, prefixPath);
+        const currentOffset = this.appendOffsets.get(prefix) ?? this.discoverLength(prefixPath);
+        this.writeAt(prefixPath, currentOffset, data);
+        this.appendOffsets.set(prefix, currentOffset + data.byteLength);
+        return { prefix, offset: currentOffset, length: data.byteLength };
+    }
+    appendAt(prefix, logicalOffset, data) {
+        const prefixPath = resolveStateRelativePath(this.stateDir, prefix);
+        this.writeAt(prefixPath, logicalOffset, data);
+        const next = logicalOffset + data.byteLength;
+        const known = this.appendOffsets.get(prefix);
+        if (known === undefined || next > known)
+            this.appendOffsets.set(prefix, next);
+    }
+    read(reference) {
+        return this.readRange(reference.prefix, reference.offset, reference.offset + reference.length);
+    }
+    readRange(prefix, start, end) {
+        if (!Number.isSafeInteger(start) || start < 0 || !Number.isSafeInteger(end) || end < start) {
+            throw new Error(`Invalid segmented log range: ${start}..${end}.`);
+        }
+        if (start === end)
+            return Buffer.alloc(0);
+        const prefixPath = resolveStateRelativePath(this.stateDir, prefix);
+        const result = Buffer.allocUnsafe(end - start);
+        let logicalOffset = start;
+        let resultOffset = 0;
+        while (logicalOffset < end) {
+            const segmentIndex = Math.floor(logicalOffset / this.segmentBytes);
+            const segmentOffset = logicalOffset % this.segmentBytes;
+            const available = Math.min(end - logicalOffset, this.segmentBytes - segmentOffset);
+            const path = segmentPath(prefixPath, segmentIndex);
+            const fd = openSync(path, fsConstants.O_RDONLY);
+            try {
+                const bytesRead = readSync(fd, result, resultOffset, available, segmentOffset);
+                if (bytesRead !== available) {
+                    throw new Error(`Segmented log ${path} ended before logical offset ${logicalOffset + available}.`);
+                }
+            }
+            finally {
+                closeSync(fd);
+            }
+            logicalOffset += available;
+            resultOffset += available;
+        }
+        return result;
+    }
+    logicalLength(prefix) {
+        const known = this.appendOffsets.get(prefix);
+        if (known !== undefined)
+            return known;
+        const prefixPath = resolveStateRelativePath(this.stateDir, prefix);
+        const length = this.discoverLength(prefixPath);
+        this.appendOffsets.set(prefix, length);
+        return length;
+    }
+    writeAt(prefixPath, logicalOffset, data) {
+        if (!Number.isSafeInteger(logicalOffset) || logicalOffset < 0) {
+            throw new Error(`Invalid segmented log offset: ${logicalOffset}.`);
+        }
+        if (data.byteLength === 0)
+            return;
+        ensureParentPrivate(prefixPath);
+        const bytes = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+        let sourceOffset = 0;
+        let current = logicalOffset;
+        while (sourceOffset < bytes.length) {
+            const segmentIndex = Math.floor(current / this.segmentBytes);
+            const segmentOffset = current % this.segmentBytes;
+            const writable = Math.min(bytes.length - sourceOffset, this.segmentBytes - segmentOffset);
+            const path = segmentPath(prefixPath, segmentIndex);
+            const fd = openSync(path, fsConstants.O_CREAT | fsConstants.O_WRONLY, 0o600);
+            try {
+                const stats = fstatSync(fd);
+                if (stats.size !== segmentOffset) {
+                    throw new Error(`Segmented log append position mismatch for ${path}: expected ${segmentOffset}, found ${stats.size}.`);
+                }
+                const written = writeSync(fd, bytes, sourceOffset, writable, segmentOffset);
+                if (written !== writable) {
+                    throw new Error(`Short write while appending segmented log ${path}.`);
+                }
+            }
+            finally {
+                closeSync(fd);
+            }
+            sourceOffset += writable;
+            current += writable;
+        }
+    }
+    discoverLength(prefixPath) {
+        const directory = dirname(prefixPath);
+        const stem = basename(prefixPath);
+        let files;
+        try {
+            files = readdirSync(directory);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return 0;
+            throw error;
+        }
+        const pattern = new RegExp(`^${escapeRegExp(stem)}\\.(\\d{6})\\.log$`);
+        let maxIndex = -1;
+        let maxSize = 0;
+        for (const file of files) {
+            const match = pattern.exec(file);
+            if (!match)
+                continue;
+            const index = Number(match[1]);
+            const size = statSync(join(directory, file)).size;
+            if (size > this.segmentBytes) {
+                throw new Error(`Segmented log shard exceeds ${this.segmentBytes} bytes: ${join(directory, file)}.`);
+            }
+            if (index > maxIndex) {
+                maxIndex = index;
+                maxSize = size;
+            }
+        }
+        if (maxIndex < 0)
+            return 0;
+        if (maxSize < this.segmentBytes)
+            return maxIndex * this.segmentBytes + maxSize;
+        return (maxIndex + 1) * this.segmentBytes;
+    }
+}
+export function segmentPath(prefixPath, index) {
+    return `${prefixPath}.${String(index).padStart(6, "0")}.log`;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/cli/setup-support.js

@@ -0,0 +1,116 @@
+import { createRequire } from "node:module";
+import * as prompts from "@clack/prompts";
+import { satisfies } from "semver";
+const SUPPORTED_NODE_RANGE = ">=20.12 <27";
+const require = createRequire(import.meta.url);
+export function isNullConfigValue(value) {
+    const normalized = value.trim().toLowerCase();
+    return !normalized || normalized === "null" || normalized === "none";
+}
+export function normalizeOptionalPublicBaseUrl(value) {
+    const trimmed = value.trim();
+    if (isNullConfigValue(trimmed))
+        return null;
+    return compactPublicBaseUrlConfig(normalizePublicBaseUrlsInput(trimmed));
+}
+export function normalizePublicBaseUrlsInput(value) {
+    const entries = value
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+    if (entries.length === 0)
+        throw new Error("Enter at least one public base URL.");
+    return Array.from(new Set(entries.map((entry) => normalizePublicBaseUrl(entry))));
+}
+export function compactPublicBaseUrlConfig(baseUrls) {
+    return baseUrls.length === 1 ? baseUrls[0] : baseUrls;
+}
+export function normalizePublicBaseUrl(value) {
+    const trimmed = value.trim();
+    const parsed = new URL(trimmed);
+    parsed.hash = "";
+    parsed.search = "";
+    parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+    return parsed.toString().replace(/\/$/, "");
+}
+export async function textPrompt(options) {
+    const result = await prompts.text({
+        ...options,
+        validate: (value) => options.validate?.(value?.trim() ? value : options.defaultValue),
+    });
+    if (prompts.isCancel(result))
+        throw new SetupCancelledError();
+    const value = String(result).trim();
+    return value || options.defaultValue;
+}
+export function validatePort(value) {
+    const port = Number(value);
+    return Number.isInteger(port) && port >= 1 && port <= 65535
+        ? undefined
+        : "Enter a port between 1 and 65535.";
+}
+export function validateRequiredPublicBaseUrls(value) {
+    const trimmed = value?.trim() ?? "";
+    if (!trimmed)
+        return "Enter at least one public base URL from your tunnel or reverse proxy.";
+    try {
+        normalizePublicBaseUrlsInput(trimmed);
+        return undefined;
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+export function assertSupportedNode() {
+    if (satisfies(process.versions.node, SUPPORTED_NODE_RANGE))
+        return;
+    throw new Error([
+        `ForgeRelay requires Node ${SUPPORTED_NODE_RANGE}.`,
+        `Current Node: ${process.version}`,
+        "",
+        "Install Node 22 LTS or use a version manager such as nvm, fnm, or mise.",
+    ].join("\n"));
+}
+export function nodeVersionStatus() {
+    return satisfies(process.versions.node, SUPPORTED_NODE_RANGE)
+        ? `supported ${SUPPORTED_NODE_RANGE}`
+        : `unsupported, requires ${SUPPORTED_NODE_RANGE}`;
+}
+export class SetupCancelledError extends Error {
+}
+export function checkSqliteNative() {
+    try {
+        const Database = require("better-sqlite3");
+        const db = new Database(":memory:");
+        db.close();
+        return "ok";
+    }
+    catch (error) {
+        return error instanceof Error ? error.message : String(error);
+    }
+}
+export function checkGitAvailable() {
+    try {
+        const { execFileSync } = require("node:child_process");
+        return execFileSync("git", ["--version"], { encoding: "utf8" }).trim();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `unavailable (${message})`;
+    }
+}
+export function checkBashShell() {
+    try {
+        const { execFileSync } = require("node:child_process");
+        const command = process.env.BASH?.trim() || "bash";
+        const version = execFileSync(command, ["--version"], {
+            encoding: "utf8",
+            windowsHide: true,
+        }).split(/\r?\n/, 1)[0]?.trim();
+        return version ? `${command} (${version})` : command;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `unavailable (${message})`;
+    }
+}

package/dist/cli.js

@@ -8,23 +8,21 @@ import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import * as prompts from "@clack/prompts";
-import { getShellConfig } from "@earendil-works/pi-coding-agent";
-import { satisfies } from "semver";
-import { loadConfig } from "./config.js";
-import { runHooksCommand } from "./hook-cli.js";
+import { loadConfig } from "./runtime/config/config.js";
+import { runHooksCommand } from "./mcp/hooks/hook-cli.js";
 import { executeSubagentSession } from "./subagents/sessions/execution.js";
 import { SubagentDeliveryMailbox } from "./subagents/sessions/delivery-mailbox.js";
 import { SubagentSessionManager } from "./subagents/sessions/manager.js";
 import { formatSubagentProviderAvailabilitySummary } from "./subagents/providers/availability.js";
 import { parseSubagentRunArgs } from "./subagents/cli-target.js";
-import { ensureForgeRelayInstanceId, generateInstanceId, generateOwnerToken, loadForgeRelayFiles, removeForgeRelayRemote, renameForgeRelayRemote, resolveSubagentsFlag, writeForgeRelayAuth, writeForgeRelayConfig, writeForgeRelayRemote, } from "./user-config.js";
-import { expandHomePath } from "./roots.js";
-import { shutdownHttpServer } from "./server-shutdown.js";
-import { publicEndpointUrl } from "./oauth/public-url.js";
-import { authenticateRemote, defaultRemoteAlias, isRemoteMcpUnauthorized, normalizeRemoteServiceTarget, refreshRemoteAuthentication, verifyRemoteMcp, } from "./remote-auth.js";
-import { defaultSshRouteAlias, parseSshRoute, readRemoteOwnerToken, withRemoteServiceEndpoint, } from "./remote-transport.js";
+import { ensureForgeRelayInstanceId, generateInstanceId, generateOwnerToken, loadForgeRelayFiles, removeForgeRelayRemote, renameForgeRelayRemote, resolveSubagentsFlag, writeForgeRelayAuth, writeForgeRelayConfig, writeForgeRelayRemote, } from "./runtime/config/user-config.js";
+import { expandHomePath } from "./mcp/filesystem/roots.js";
+import { shutdownHttpServer } from "./mcp/server/transport/server-shutdown.js";
+import { publicEndpointUrl } from "./mcp/oauth/public-url.js";
+import { authenticateRemote, defaultRemoteAlias, isRemoteMcpUnauthorized, normalizeRemoteServiceTarget, refreshRemoteAuthentication, verifyRemoteMcp, } from "./workspaces/relay/auth/remote-auth.js";
+import { defaultSshRouteAlias, parseSshRoute, readRemoteOwnerToken, withRemoteServiceEndpoint, } from "./workspaces/relay/transport/remote-transport.js";
+import { normalizeOptionalPublicBaseUrl, normalizePublicBaseUrlsInput, compactPublicBaseUrlConfig, textPrompt, validatePort, validateRequiredPublicBaseUrls, assertSupportedNode, nodeVersionStatus, SetupCancelledError, checkSqliteNative, checkGitAvailable, checkBashShell } from "./cli/setup-support.js";
 const require = createRequire(import.meta.url);
-const SUPPORTED_NODE_RANGE = ">=20.12 <27";
 async function main(argv) {
     assertSupportedNode();
     const [rawCommand, ...args] = argv;
@@ -74,11 +72,11 @@ function normalizeCommand(command) {
 async function ensureConfigured() {
     const files = loadForgeRelayFiles();
     if (files.configExists && files.authExists) {
-        ensureForgeRelayInstanceId();
+        await ensureForgeRelayInstanceId();
         return;
     }
     if (process.env.FORGERELAY_OAUTH_OWNER_TOKEN) {
-        ensureForgeRelayInstanceId();
+        await ensureForgeRelayInstanceId();
         return;
     }
     if (!input.isTTY || !output.isTTY) {
@@ -156,7 +154,7 @@ async function runInit({ force }) {
             instanceId: files.auth.instanceId ?? generateInstanceId(),
         };
         const configPath = writeForgeRelayConfig(config);
-        const authPath = writeForgeRelayAuth(auth);
+        const authPath = await writeForgeRelayAuth(auth);
         const lines = [
             `Config: ${configPath}`,
             `Auth: ${authPath}`,
@@ -316,7 +314,7 @@ async function runAuthCommand(args) {
         if (!fromAlias || !toAlias || extra.length > 0) {
             throw new Error("Usage: forgerelay auth rename <old-alias> <new-alias>");
         }
-        renameForgeRelayRemote(fromAlias, toAlias);
+        await renameForgeRelayRemote(fromAlias, toAlias);
         console.log(`Renamed remote ${fromAlias} to ${toAlias}.`);
         return;
     }
@@ -324,7 +322,7 @@ async function runAuthCommand(args) {
         const [alias, ...extra] = rest;
         if (!alias || extra.length > 0)
             throw new Error("Usage: forgerelay auth remove <alias>");
-        removeForgeRelayRemote(alias);
+        await removeForgeRelayRemote(alias);
         console.log(`Removed remote ${alias}.`);
         return;
     }
@@ -341,7 +339,7 @@ async function runAuthCommand(args) {
             let refreshed = false;
             if (remote.accessTokenExpiresAt <= Math.floor(Date.now() / 1000)) {
                 remote = await refreshRemoteAuthentication(remote, endpoint);
-                writeForgeRelayRemote(alias, remote);
+                await writeForgeRelayRemote(alias, remote);
                 refreshed = true;
             }
             try {
@@ -351,7 +349,7 @@ async function runAuthCommand(args) {
                 if (refreshed || !isRemoteMcpUnauthorized(error))
                     throw error;
                 remote = await refreshRemoteAuthentication(remote, endpoint);
-                writeForgeRelayRemote(alias, remote);
+                await writeForgeRelayRemote(alias, remote);
                 await verifyRemoteMcp(remote, endpoint);
             }
         });
@@ -378,9 +376,9 @@ async function runAuthCommand(args) {
         : defaultRemoteAlias(remote.target);
     const alias = parsed.alias?.trim() || existingAlias || defaultAlias;
     if (!files.auth.instanceId) {
-        ensureForgeRelayInstanceId();
+        await ensureForgeRelayInstanceId();
     }
-    writeForgeRelayRemote(alias, remote);
+    await writeForgeRelayRemote(alias, remote);
     console.log(`Authenticated remote ${alias} (${remote.instanceId}).`);
 }
 async function runDoctor() {
@@ -641,112 +639,6 @@ function printVersion() {
     }
     console.log(packageJson.version);
 }
-function isNullConfigValue(value) {
-    const normalized = value.trim().toLowerCase();
-    return !normalized || normalized === "null" || normalized === "none";
-}
-function normalizeOptionalPublicBaseUrl(value) {
-    const trimmed = value.trim();
-    if (isNullConfigValue(trimmed))
-        return null;
-    return compactPublicBaseUrlConfig(normalizePublicBaseUrlsInput(trimmed));
-}
-function normalizePublicBaseUrlsInput(value) {
-    const entries = value
-        .split(",")
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-    if (entries.length === 0)
-        throw new Error("Enter at least one public base URL.");
-    return Array.from(new Set(entries.map((entry) => normalizePublicBaseUrl(entry))));
-}
-function compactPublicBaseUrlConfig(baseUrls) {
-    return baseUrls.length === 1 ? baseUrls[0] : baseUrls;
-}
-function normalizePublicBaseUrl(value) {
-    const trimmed = value.trim();
-    const parsed = new URL(trimmed);
-    parsed.hash = "";
-    parsed.search = "";
-    parsed.pathname = parsed.pathname.replace(/\/+$/, "");
-    return parsed.toString().replace(/\/$/, "");
-}
-async function textPrompt(options) {
-    const result = await prompts.text({
-        ...options,
-        validate: (value) => options.validate?.(value?.trim() ? value : options.defaultValue),
-    });
-    if (prompts.isCancel(result))
-        throw new SetupCancelledError();
-    const value = String(result).trim();
-    return value || options.defaultValue;
-}
-function validatePort(value) {
-    const port = Number(value);
-    return Number.isInteger(port) && port >= 1 && port <= 65535
-        ? undefined
-        : "Enter a port between 1 and 65535.";
-}
-function validateRequiredPublicBaseUrls(value) {
-    const trimmed = value?.trim() ?? "";
-    if (!trimmed)
-        return "Enter at least one public base URL from your tunnel or reverse proxy.";
-    try {
-        normalizePublicBaseUrlsInput(trimmed);
-        return undefined;
-    }
-    catch (error) {
-        return error instanceof Error ? error.message : String(error);
-    }
-}
-function assertSupportedNode() {
-    if (satisfies(process.versions.node, SUPPORTED_NODE_RANGE))
-        return;
-    throw new Error([
-        `ForgeRelay requires Node ${SUPPORTED_NODE_RANGE}.`,
-        `Current Node: ${process.version}`,
-        "",
-        "Install Node 22 LTS or use a version manager such as nvm, fnm, or mise.",
-    ].join("\n"));
-}
-function nodeVersionStatus() {
-    return satisfies(process.versions.node, SUPPORTED_NODE_RANGE)
-        ? `supported ${SUPPORTED_NODE_RANGE}`
-        : `unsupported, requires ${SUPPORTED_NODE_RANGE}`;
-}
-class SetupCancelledError extends Error {
-}
-function checkSqliteNative() {
-    try {
-        const Database = require("better-sqlite3");
-        const db = new Database(":memory:");
-        db.close();
-        return "ok";
-    }
-    catch (error) {
-        return error instanceof Error ? error.message : String(error);
-    }
-}
-function checkGitAvailable() {
-    try {
-        const { execFileSync } = require("node:child_process");
-        return execFileSync("git", ["--version"], { encoding: "utf8" }).trim();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return `unavailable (${message})`;
-    }
-}
-function checkBashShell() {
-    try {
-        const { shell, args } = getShellConfig();
-        return `${shell} ${args.join(" ")}`;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return `unavailable (${message})`;
-    }
-}
 main(process.argv.slice(2)).catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exitCode = 1;

package/dist/lsp/code-intelligence.js

@@ -5,7 +5,7 @@ import { pathToFileURL } from "node:url";
 import { createMessageConnection } from "vscode-jsonrpc/node";
 import { DefinitionRequest, DocumentDiagnosticReportKind, DocumentDiagnosticRequest, DocumentSymbolRequest, ExitNotification, HoverRequest, InitializeRequest, ReferencesRequest, InitializedNotification, MarkupKind, PositionEncodingKind, PublishDiagnosticsNotification, ShutdownRequest, WorkspaceSymbolRequest, } from "vscode-languageserver-protocol";
 import { LanguageServerConfigurationError, } from "./language-server-config.js";
-import { terminateProcessTree } from "../process-platform.js";
+import { terminateProcessTree } from "../mcp/process/process-platform.js";
 import { CodeIntelligenceError } from "./code-intelligence-error.js";
 import { DEFAULT_CODE_INTELLIGENCE_RESULT_LIMIT } from "./code-intelligence-types.js";
 import { normalizeHoverContents } from "./normalization/hover.js";

package/dist/lsp/test-support/server-fixture.js

@@ -4,16 +4,16 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
-import { ActivityAuditStore } from "../../activity/audit-store.js";
-import { BashOutputStore } from "../../activity/bash-output-store.js";
-import { HostTurnStore } from "../../activity/host-turn-store.js";
-import { ActivityLifecycle } from "../../activity/lifecycle.js";
-import { ActivityQueryService } from "../../activity/query-service.js";
-import { loadConfig } from "../../config.js";
-import { createReviewCheckpointManager } from "../../review-checkpoints.js";
-import { ProcessManager } from "../../process-sessions.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 { createReviewCheckpointManager } from "../../workspaces/review/review-checkpoints.js";
+import { ProcessManager } from "../../mcp/process/process-sessions.js";
 import { createMcpServer } from "../../server.js";
-import { SqliteWorkspaceStore } from "../../workspace-store.js";
+import { SqliteWorkspaceStore } from "../../workspaces/state/workspace-store.js";
 import { WorkspaceRegistry } from "../../workspaces.js";
 import { CodeIntelligenceManager } from "../runtime/manager.js";
 export async function createCodeIntelligenceServerFixture(t, options = {}) {