@akira-tl/forgerelay 0.8.8 → 0.8.10

package/dist/lsp/runtime/manager.js

@@ -1,7 +1,9 @@
+import { createHash } from "node:crypto";
 import { realpath } from "node:fs/promises";
 import { resolve, sep } from "node:path";
 import { CodeIntelligenceError, LanguageService, languageServiceKey, } from "../code-intelligence.js";
 import { LanguageServerConfigurationError, resolveLanguageProject, } from "../language-server-config.js";
+import { managedLanguageServerIdForCommand, managedLanguageServerRuntimeIdentity, managedTypeScriptTsserverPath, withManagedLanguageServerPath, } from "./managed-language-servers.js";
 const LANGUAGE_SERVICE_IDLE_MS = 10 * 60 * 1_000;
 const LANGUAGE_SERVICE_CLEANUP_INTERVAL_MS = 60 * 1_000;
 const MAX_LANGUAGE_SERVICES = 16;
@@ -50,11 +52,12 @@ export class CodeIntelligenceManager {
         try {
             canonicalWorkspaceRoot = await realpath(resolve(workspaceRoot));
             this.assertWorkspaceRootAvailable(canonicalWorkspaceRoot);
-            project = await resolveLanguageProject({
+            project = withManagedLanguageServerRuntime(await resolveLanguageProject({
                 workspaceRoot: canonicalWorkspaceRoot,
                 sourcePath: input.path,
                 globalConfig: this.config.languageServers,
-            });
+                env: withManagedLanguageServerPath(process.env, this.config.configDir),
+            }), this.config.configDir);
         }
         catch (error) {
             if (error instanceof LanguageServerConfigurationError) {
@@ -319,6 +322,38 @@ export class CodeIntelligenceManager {
         await candidate[1].shutdown();
     }
 }
+function withManagedLanguageServerRuntime(project, configDir) {
+    if (!configDir)
+        return project;
+    const managedId = managedLanguageServerIdForCommand(configDir, project.definition.command);
+    if (!managedId)
+        return project;
+    const runtimeIdentity = managedLanguageServerRuntimeIdentity(configDir, managedId);
+    if (!runtimeIdentity)
+        return project;
+    let initializationOptions = project.definition.initializationOptions;
+    if (managedId === "typescript") {
+        const tsserverPath = managedTypeScriptTsserverPath(configDir);
+        if (!tsserverPath)
+            return project;
+        initializationOptions = { tsserver: { path: tsserverPath } };
+    }
+    const fingerprint = createHash("sha256")
+        .update(project.definition.fingerprint)
+        .update("\0")
+        .update(runtimeIdentity)
+        .update("\0")
+        .update(JSON.stringify(initializationOptions ?? null))
+        .digest("hex");
+    return {
+        ...project,
+        definition: {
+            ...project.definition,
+            ...(initializationOptions === undefined ? {} : { initializationOptions }),
+            fingerprint,
+        },
+    };
+}
 function identityBelongsToWorkspaceRoot(identity, workspaceRoot) {
     try {
         const parsed = JSON.parse(identity);

package/dist/lsp/runtime/process-launch.js

@@ -0,0 +1,3 @@
+export function languageServerCommandRequiresShell(command, platform = process.platform) {
+    return platform === "win32" && /\.(?:cmd|bat)$/i.test(command);
+}

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 = {}) {
@@ -35,6 +35,7 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
         FORGERELAY_OAUTH_OWNER_TOKEN: "test-owner-token-that-is-long-enough",
         PORT: "1",
     });
+    config.allowAgentLanguageServerInstall = options.allowAgentLanguageServerInstall === true;
     const store = new SqliteWorkspaceStore(stateDir);
     const workspaces = new WorkspaceRegistry(config, store);
     const auditStore = new ActivityAuditStore(stateDir);
@@ -46,7 +47,9 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
         turnIdForConversation: (conversationScopeId, workspaceId) => activityQueries.currentTurnId(conversationScopeId, workspaceId),
     });
     const codeIntelligence = new CodeIntelligenceManager(config, options.codeIntelligenceOptions);
-    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence, activityLifecycle, bashOutputStore, activityQueries);
+    const server = createMcpServer(config, workspaces, createReviewCheckpointManager(), processSessions, [], [], codeIntelligence, activityLifecycle, bashOutputStore, activityQueries, options.managedLanguageServerInstaller
+        ? { managedLanguageServerInstaller: options.managedLanguageServerInstaller }
+        : {});
     const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
     const client = new Client({ name: "forgerelay-code-intelligence-test-client", version: "1.0.0" });
     await Promise.all([client.connect(clientTransport), server.connect(serverTransport)]);
@@ -73,7 +76,7 @@ export async function createCodeIntelligenceServerFixture(t, options = {}) {
             retryDelay: 100,
         });
     });
-    return { client, project, codeIntelligence, close };
+    return { client, project, config, codeIntelligence, close };
 }
 export async function callOpen(client, path, conversationScopeId) {
     return client.callTool({

package/dist/mcp/filesystem/filesystem-tools.js

@@ -0,0 +1,245 @@
+import { constants } from "node:fs";
+import { access, mkdir, readFile, realpath, writeFile, } from "node:fs/promises";
+import { dirname } from "node:path";
+import { createPatch } from "diff";
+import { resolveCanonicalAllowedPath } from "./roots.js";
+const DEFAULT_MAX_LINES = 2_000;
+const DEFAULT_MAX_BYTES = 50 * 1_024;
+const mutationQueues = new Map();
+function textContent(text) {
+    return [{ type: "text", text }];
+}
+function failed(error) {
+    return {
+        content: textContent(error instanceof Error ? error.message : String(error)),
+        isError: true,
+    };
+}
+export async function readFileTool(input, context) {
+    try {
+        const path = await resolveCanonicalAllowedPath(input.path, context.cwd, context.readRoots ?? [context.root]);
+        await access(path, constants.R_OK);
+        const buffer = await readFile(path);
+        const mimeType = supportedImageMimeType(buffer);
+        if (mimeType) {
+            return {
+                content: [
+                    { type: "text", text: `Read image file [${mimeType}]` },
+                    { type: "image", data: buffer.toString("base64"), mimeType },
+                ],
+            };
+        }
+        return { content: textContent(readText(buffer.toString("utf8"), input)) };
+    }
+    catch (error) {
+        return failed(error);
+    }
+}
+export async function writeFileTool(input, context) {
+    try {
+        const path = await resolveCanonicalAllowedPath(input.path, context.cwd, context.fileRoots ?? [context.root]);
+        await withMutationQueue(path, async () => {
+            await mkdir(dirname(path), { recursive: true });
+            await writeFile(path, input.content, "utf8");
+        });
+        return { content: textContent(`Successfully wrote ${input.content.length} bytes to ${input.path}`) };
+    }
+    catch (error) {
+        return failed(error);
+    }
+}
+export async function editFileTool(input, context, signal) {
+    try {
+        const path = await resolveCanonicalAllowedPath(input.path, context.cwd, context.fileRoots ?? [context.root]);
+        const details = await withMutationQueue(path, async () => {
+            signal?.throwIfAborted();
+            await access(path, constants.R_OK | constants.W_OK);
+            signal?.throwIfAborted();
+            const raw = await readFile(path, "utf8");
+            signal?.throwIfAborted();
+            const applied = applyExactEdits(raw, input.edits, input.path);
+            await writeFile(path, applied.output, "utf8");
+            signal?.throwIfAborted();
+            return applied.details;
+        });
+        return {
+            content: textContent(`Successfully replaced ${input.edits.length} block(s) in ${input.path}.`),
+            details,
+        };
+    }
+    catch (error) {
+        return failed(error);
+    }
+}
+export async function preflightEditFiles(paths, edits, context, signal) {
+    const seen = new Map();
+    for (const path of paths) {
+        signal?.throwIfAborted();
+        const absolute = await resolveCanonicalAllowedPath(path, context.cwd, context.fileRoots ?? [context.root]);
+        const canonical = await realpath(absolute);
+        const previous = seen.get(canonical);
+        if (previous) {
+            throw new Error(`Bulk Edit targets overlap: ${previous} and ${path} resolve to the same file.`);
+        }
+        seen.set(canonical, path);
+        await access(absolute, constants.R_OK | constants.W_OK);
+        const content = await readFile(absolute, "utf8");
+        applyExactEdits(content, edits, path);
+    }
+}
+function readText(content, input) {
+    const lines = content.split("\n");
+    const startIndex = Math.max(0, (input.offset ?? 1) - 1);
+    if (startIndex >= lines.length) {
+        throw new Error(`Offset ${input.offset} is beyond end of file (${lines.length} lines total)`);
+    }
+    const explicitEnd = input.limit === undefined
+        ? lines.length
+        : Math.min(lines.length, startIndex + input.limit);
+    const selected = lines.slice(startIndex, explicitEnd);
+    const limited = truncateLinesAndBytes(selected, DEFAULT_MAX_LINES, DEFAULT_MAX_BYTES);
+    const startLine = startIndex + 1;
+    const endLine = startLine + limited.lines.length - 1;
+    let output = limited.lines.join("\n");
+    if (limited.truncated) {
+        const nextOffset = endLine + 1;
+        output += `\n\n[Showing lines ${startLine}-${endLine} of ${lines.length}. Use offset=${nextOffset} to continue.]`;
+    }
+    else if (explicitEnd < lines.length) {
+        const remaining = lines.length - explicitEnd;
+        output += `\n\n[${remaining} more lines in file. Use offset=${explicitEnd + 1} to continue.]`;
+    }
+    return output;
+}
+function truncateLinesAndBytes(lines, maxLines, maxBytes) {
+    const output = [];
+    let bytes = 0;
+    for (const line of lines) {
+        if (output.length >= maxLines)
+            return { lines: output, truncated: true };
+        const prefix = output.length === 0 ? "" : "\n";
+        const lineBytes = Buffer.byteLength(prefix + line, "utf8");
+        if (bytes + lineBytes > maxBytes) {
+            if (output.length === 0) {
+                return {
+                    lines: [`[Line exceeds ${maxBytes} byte read limit. Use bash for byte-oriented inspection.]`],
+                    truncated: true,
+                };
+            }
+            return { lines: output, truncated: true };
+        }
+        output.push(line);
+        bytes += lineBytes;
+    }
+    return { lines: output, truncated: false };
+}
+function applyExactEdits(rawContent, edits, displayPath) {
+    if (!Array.isArray(edits) || edits.length === 0) {
+        throw new Error("Edit tool input is invalid. edits must contain at least one replacement.");
+    }
+    const { bom, text } = stripBom(rawContent);
+    const lineEnding = detectLineEnding(text);
+    const original = normalizeLineEndings(text);
+    const prepared = edits.map((edit, index) => {
+        if (typeof edit.oldText !== "string" || typeof edit.newText !== "string" || edit.oldText.length === 0) {
+            throw new Error(`Edit ${index + 1} must contain non-empty oldText and string newText.`);
+        }
+        const oldText = normalizeLineEndings(edit.oldText);
+        const newText = normalizeLineEndings(edit.newText);
+        const start = original.indexOf(oldText);
+        if (start < 0) {
+            throw new Error(`Could not edit ${displayPath}: oldText for replacement ${index + 1} did not match.`);
+        }
+        if (original.indexOf(oldText, start + oldText.length) >= 0) {
+            throw new Error(`Could not edit ${displayPath}: oldText for replacement ${index + 1} must be unique but matched multiple locations.`);
+        }
+        return { start, end: start + oldText.length, newText };
+    }).sort((left, right) => left.start - right.start);
+    for (let index = 1; index < prepared.length; index += 1) {
+        if (prepared[index].start < prepared[index - 1].end) {
+            throw new Error(`Could not edit ${displayPath}: replacements overlap in the original file.`);
+        }
+    }
+    let cursor = 0;
+    let updated = "";
+    for (const edit of prepared) {
+        updated += original.slice(cursor, edit.start);
+        updated += edit.newText;
+        cursor = edit.end;
+    }
+    updated += original.slice(cursor);
+    const firstChangedLine = prepared.length === 0
+        ? undefined
+        : original.slice(0, prepared[0].start).split("\n").length;
+    const patch = createPatch(displayPath, original, updated, "", "", { context: 3 });
+    const diff = patch;
+    const output = bom + restoreLineEndings(updated, lineEnding);
+    return { output, details: { diff, patch, firstChangedLine } };
+}
+function stripBom(content) {
+    return content.charCodeAt(0) === 0xfeff
+        ? { bom: "\ufeff", text: content.slice(1) }
+        : { bom: "", text: content };
+}
+function detectLineEnding(content) {
+    if (content.includes("\r\n"))
+        return "\r\n";
+    if (content.includes("\r"))
+        return "\r";
+    return "\n";
+}
+function normalizeLineEndings(content) {
+    return content.replace(/\r\n?/g, "\n");
+}
+function restoreLineEndings(content, lineEnding) {
+    return lineEnding === "\n" ? content : content.replaceAll("\n", lineEnding);
+}
+function supportedImageMimeType(buffer) {
+    if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+        return "image/png";
+    }
+    if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+        return "image/jpeg";
+    }
+    const header6 = buffer.subarray(0, 6).toString("ascii");
+    if (header6 === "GIF87a" || header6 === "GIF89a")
+        return "image/gif";
+    if (buffer.length >= 12 &&
+        buffer.subarray(0, 4).toString("ascii") === "RIFF" &&
+        buffer.subarray(8, 12).toString("ascii") === "WEBP")
+        return "image/webp";
+    if (buffer.length >= 2 && buffer.subarray(0, 2).toString("ascii") === "BM")
+        return "image/bmp";
+    return undefined;
+}
+async function withMutationQueue(path, operation) {
+    const canonical = await canonicalMutationPath(path);
+    const previous = mutationQueues.get(canonical) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+        release = resolve;
+    });
+    mutationQueues.set(canonical, previous.then(() => current));
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release();
+        if (mutationQueues.get(canonical) === current)
+            mutationQueues.delete(canonical);
+    }
+}
+async function canonicalMutationPath(path) {
+    try {
+        return await realpath(path);
+    }
+    catch {
+        try {
+            return `${await realpath(dirname(path))}/${path.slice(dirname(path).length + 1)}`;
+        }
+        catch {
+            return path;
+        }
+    }
+}

package/dist/mcp/hooks/command-runner.js

@@ -0,0 +1,79 @@
+import { spawn } from "node:child_process";
+import { terminateProcessTree } from "../process/process-platform.js";
+const MAX_CAPTURE_BYTES = 64 * 1024;
+export function executeHookCommand(input) {
+    input.signal?.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const child = spawn(input.executable, input.args, {
+            cwd: input.cwd,
+            env: input.env,
+            detached: input.detached,
+            windowsHide: true,
+            windowsVerbatimArguments: input.windowsVerbatimArguments,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let forceKillTimer;
+        let aborted = false;
+        const abort = () => {
+            if (aborted)
+                return;
+            aborted = true;
+            terminateProcessTree(child, "SIGTERM", input.detached);
+            forceKillTimer = setTimeout(() => {
+                terminateProcessTree(child, "SIGKILL", input.detached);
+            }, 500);
+            forceKillTimer.unref();
+        };
+        input.signal?.addEventListener("abort", abort, { once: true });
+        child.stdout?.on("data", (chunk) => {
+            stdout = appendCaptured(stdout, chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr = appendCaptured(stderr, chunk);
+        });
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            terminateProcessTree(child, "SIGTERM", input.detached);
+            forceKillTimer = setTimeout(() => {
+                terminateProcessTree(child, "SIGKILL", input.detached);
+            }, 500);
+            forceKillTimer.unref();
+        }, input.timeoutMs);
+        timeout.unref();
+        child.once("error", (error) => {
+            clearTimeout(timeout);
+            if (forceKillTimer)
+                clearTimeout(forceKillTimer);
+            input.signal?.removeEventListener("abort", abort);
+            reject(error);
+        });
+        child.once("close", (exitCode, signal) => {
+            clearTimeout(timeout);
+            if (forceKillTimer)
+                clearTimeout(forceKillTimer);
+            input.signal?.removeEventListener("abort", abort);
+            if (aborted) {
+                reject(input.signal?.reason instanceof Error
+                    ? input.signal.reason
+                    : Object.assign(new Error("Hook execution cancelled by Host."), { name: "AbortError" }));
+                return;
+            }
+            resolve({ exitCode, signal, stdout, stderr, timedOut });
+        });
+    });
+}
+function appendCaptured(current, chunk) {
+    if (Buffer.byteLength(current) >= MAX_CAPTURE_BYTES)
+        return current;
+    const next = current + chunk.toString();
+    if (Buffer.byteLength(next) <= MAX_CAPTURE_BYTES)
+        return next;
+    return Buffer.from(next).subarray(0, MAX_CAPTURE_BYTES).toString("utf8");
+}
+export function hookFailureOutput(stdout, stderr) {
+    const output = (stderr.trim() || stdout.trim()).replace(/\s+/g, " ");
+    return output.length > 1_000 ? `${output.slice(0, 997)}...` : output;
+}

package/dist/{hook-cli.js → mcp/hooks/hook-cli.js}

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { HOOK_EVENTS, loadProjectHookConfig, mergeHookConfigs, parseHookConfig, } from "./hooks.js";
-import { loadForgeRelayFiles } from "./user-config.js";
+import { loadForgeRelayFiles } from "../../runtime/config/user-config.js";
 export async function checkHookConfiguration(projectRoot, globalHooks = loadGlobalHooks()) {
     const globalEntries = flattenHooks(globalHooks, "global");
     const project = await loadProjectHookConfig(projectRoot);

package/dist/{hooks.js → mcp/hooks/hooks.js}

@@ -1,9 +1,9 @@
-import { spawn } from "node:child_process";
 import { readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { performance } from "node:perf_hooks";
-import { commandPreview, logEvent, workspaceLogLabel } from "./logger.js";
-import { resolveShellCommand, terminateProcessTree } from "./process-platform.js";
+import { commandPreview, logEvent, workspaceLogLabel } from "../../runtime/logging/logger.js";
+import { resolveShellCommand } from "../process/process-platform.js";
+import { executeHookCommand, hookFailureOutput } from "./command-runner.js";
 export const HOOK_EVENTS = [
     "WorkspaceOpen",
     "BeforeTool",
@@ -19,7 +19,6 @@ const DEFAULT_HOOK_TIMEOUT_SECONDS = 30;
 const MAX_HOOK_TIMEOUT_SECONDS = 300;
 const PROJECT_HOOKS_PATH = join(".forgerelay", "hooks.json");
 const PROJECT_HOOKS_DIR = join(".forgerelay", "hooks");
-const MAX_CAPTURE_BYTES = 64 * 1024;
 const BLOCKING_EVENTS = new Set(["BeforeTool", "BeforeWorktreeClose"]);
 const EVENT_SET = new Set(HOOK_EVENTS);
 export class HookExecutionError extends Error {
@@ -529,82 +528,6 @@ function hookEnvironment(baseEnv, event, invocation) {
         FORGERELAY_TOOL_NAME: typeof invocation.payload?.tool === "string" ? invocation.payload.tool : undefined,
     };
 }
-function executeHookCommand(input) {
-    input.signal?.throwIfAborted();
-    return new Promise((resolve, reject) => {
-        const child = spawn(input.executable, input.args, {
-            cwd: input.cwd,
-            env: input.env,
-            detached: input.detached,
-            windowsHide: true,
-            windowsVerbatimArguments: input.windowsVerbatimArguments,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        let forceKillTimer;
-        let aborted = false;
-        const abort = () => {
-            if (aborted)
-                return;
-            aborted = true;
-            terminateProcessTree(child, "SIGTERM", input.detached);
-            forceKillTimer = setTimeout(() => {
-                terminateProcessTree(child, "SIGKILL", input.detached);
-            }, 500);
-            forceKillTimer.unref();
-        };
-        input.signal?.addEventListener("abort", abort, { once: true });
-        child.stdout?.on("data", (chunk) => {
-            stdout = appendCaptured(stdout, chunk);
-        });
-        child.stderr?.on("data", (chunk) => {
-            stderr = appendCaptured(stderr, chunk);
-        });
-        const timeout = setTimeout(() => {
-            timedOut = true;
-            terminateProcessTree(child, "SIGTERM", input.detached);
-            forceKillTimer = setTimeout(() => {
-                terminateProcessTree(child, "SIGKILL", input.detached);
-            }, 500);
-            forceKillTimer.unref();
-        }, input.timeoutMs);
-        timeout.unref();
-        child.once("error", (error) => {
-            clearTimeout(timeout);
-            if (forceKillTimer)
-                clearTimeout(forceKillTimer);
-            input.signal?.removeEventListener("abort", abort);
-            reject(error);
-        });
-        child.once("close", (exitCode, signal) => {
-            clearTimeout(timeout);
-            if (forceKillTimer)
-                clearTimeout(forceKillTimer);
-            input.signal?.removeEventListener("abort", abort);
-            if (aborted) {
-                reject(input.signal?.reason instanceof Error
-                    ? input.signal.reason
-                    : Object.assign(new Error("Hook execution cancelled by Host."), { name: "AbortError" }));
-                return;
-            }
-            resolve({ exitCode, signal, stdout, stderr, timedOut });
-        });
-    });
-}
-function appendCaptured(current, chunk) {
-    if (Buffer.byteLength(current) >= MAX_CAPTURE_BYTES)
-        return current;
-    const next = current + chunk.toString();
-    if (Buffer.byteLength(next) <= MAX_CAPTURE_BYTES)
-        return next;
-    return Buffer.from(next).subarray(0, MAX_CAPTURE_BYTES).toString("utf8");
-}
-function hookFailureOutput(stdout, stderr) {
-    const output = (stderr.trim() || stdout.trim()).replace(/\s+/g, " ");
-    return output.length > 1_000 ? `${output.slice(0, 997)}...` : output;
-}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/{oauth-provider.js → mcp/oauth/oauth-provider.js}

@@ -23,7 +23,7 @@ function htmlEscape(value) {
         .replaceAll("'", "'");
 }
 function formHtml(params) {
-    const scopeText = params.scopes.length > 0 ? params.scopes.join(" ") : "devspace";
+    const scopeText = params.scopes.length > 0 ? params.scopes.join(" ") : "forgerelay";
     const resourceText = params.resource?.href ?? "ForgeRelay MCP endpoint";
     const error = params.error
         ? `<p class="error">${htmlEscape(params.error)}</p>`

package/dist/{oauth-store.js → mcp/oauth/oauth-store.js}

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { InvalidRequestError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
-import { openDatabase } from "./db/client.js";
+import { openDatabase } from "../../runtime/state/db/client.js";
 function redirectHostAllowed(redirectUri, allowedHosts) {
     let parsed;
     try {
@@ -9,9 +9,10 @@ function redirectHostAllowed(redirectUri, allowedHosts) {
     catch {
         return false;
     }
-    if (["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname))
-        return true;
-    return allowedHosts.includes(parsed.hostname);
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname);
+    if (loopback)
+        return parsed.protocol === "http:" || parsed.protocol === "https:";
+    return parsed.protocol === "https:" && allowedHosts.includes(parsed.hostname);
 }
 export class SqliteOAuthStore {
     database;

package/dist/{operations → mcp/operations}/native-bulk-mutations.js

@@ -1,5 +1,5 @@
-import { preflightDeletePaths } from "../file-mutations.js";
-import { preflightEditFiles } from "../pi-tools.js";
+import { preflightDeletePaths } from "../filesystem/file-mutations.js";
+import { preflightEditFiles } from "../filesystem/filesystem-tools.js";
 import { openAiConversationScopeId } from "../request-meta.js";
 import { executeSequentialBulkMutation } from "./bulk-mutation.js";
 export class NativeBulkMutationExecutor {