@akira-tl/forgerelay 0.8.8 → 0.8.9

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

@@ -1,15 +1,13 @@
 import { randomBytes } from "node:crypto";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from "node:fs";
 import { join } from "node:path";
 import { CallToolResultSchema } from "@modelcontextprotocol/sdk/types.js";
-import { isRemoteMcpUnauthorized, refreshRemoteAuthentication, } from "./remote-auth.js";
-import { RemoteMcpConnectionPool } from "./remote-mcp-connection-pool.js";
-import { withRemoteServiceEndpoint } from "./remote-transport.js";
-import { loadForgeRelayFiles, writeForgeRelayRemote, } from "./user-config.js";
-const ROUTE_LOCK_RETRY_MS = 10;
-const ROUTE_LOCK_TIMEOUT_MS = 5_000;
-const ROUTE_LOCK_STALE_MS = 30_000;
-const ROUTE_LOCK_SLEEP = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+import { isRemoteMcpUnauthorized, refreshRemoteAuthentication, } from "./auth/remote-auth.js";
+import { RemoteMcpConnectionPool } from "./transport/remote-mcp-connection-pool.js";
+import { withFileLock } from "../../runtime/state/lock/file-lock.js";
+import { withRemoteServiceEndpoint } from "./transport/remote-transport.js";
+import { loadForgeRelayFiles, writeForgeRelayRemote, } from "../../runtime/config/user-config.js";
+import { assertRemoteToolSucceeded, stringField, copyStringField, copyBooleanField, copyNumberField, safeTaskSummary, toolResultText, remapToolResultWorkspaceId, replaceExactWorkspaceId, sanitizedRemoteError, errorMessage } from "./result-support.js";
 export class RemoteWorkspaceRelay {
     routes = new Map();
     turnRoutes = new Map();
@@ -109,7 +107,7 @@ export class RemoteWorkspaceRelay {
             throw new Error("Remote open_workspace response did not include a valid workspace mode.");
         }
         const sourceRoot = typeof structured?.sourceRoot === "string" ? structured.sourceRoot : undefined;
-        const route = this.findOrCreateRoute({
+        const route = await this.findOrCreateRoute({
             remoteInstanceId: resolved.remote.instanceId,
             remoteWorkspaceId,
             root,
@@ -167,7 +165,7 @@ export class RemoteWorkspaceRelay {
             ? structured.mode
             : route.mode;
         const sourceRoot = typeof structured?.sourceRoot === "string" ? structured.sourceRoot : route.sourceRoot;
-        this.findOrCreateRoute({
+        await this.findOrCreateRoute({
             remoteInstanceId: route.remoteInstanceId,
             remoteWorkspaceId: route.remoteWorkspaceId,
             root,
@@ -194,6 +192,9 @@ export class RemoteWorkspaceRelay {
     async bash(gatewayWorkspaceId, input, conversationScopeId) {
         return this.callWorkspaceTool(gatewayWorkspaceId, "bash", input, conversationScopeId);
     }
+    async workspaceInstruction(gatewayWorkspaceId, path, conversationScopeId) {
+        return this.callWorkspaceTool(gatewayWorkspaceId, "workspace_instruction", { path }, conversationScopeId);
+    }
     async execCommand(gatewayWorkspaceId, input, conversationScopeId) {
         return this.callWorkspaceTool(gatewayWorkspaceId, "exec_command", input, conversationScopeId);
     }
@@ -296,7 +297,7 @@ export class RemoteWorkspaceRelay {
         const remoteStructured = result.structuredContent;
         if (action === "delete") {
             this.routes.delete(gatewayWorkspaceId);
-            this.deletePersistedRoute(gatewayWorkspaceId);
+            await this.deletePersistedRoute(gatewayWorkspaceId);
         }
         for (const [turnId, routedWorkspaceId] of this.turnRoutes) {
             if (routedWorkspaceId === gatewayWorkspaceId)
@@ -356,35 +357,33 @@ export class RemoteWorkspaceRelay {
             this.routes.set(workspaceId, route);
         }
     }
-    findOrCreateRoute(input) {
-        let selected;
+    async findOrCreateRoute(input) {
         mkdirSync(this.routeStateDir, { recursive: true });
-        this.withRouteFileLock(() => {
+        const selected = await withFileLock(`${this.routeStatePath}.lock`, () => {
             const routes = this.readRoutesFromDisk();
             const existing = [...routes.values()]
                 .filter((route) => route.remoteInstanceId === input.remoteInstanceId &&
                 route.remoteWorkspaceId === input.remoteWorkspaceId)
                 .sort((left, right) => left.gatewayWorkspaceId.localeCompare(right.gatewayWorkspaceId))[0];
-            selected = {
+            const route = {
                 gatewayWorkspaceId: existing?.gatewayWorkspaceId ?? this.allocateGatewayWorkspaceId(routes),
                 ...input,
             };
-            routes.set(selected.gatewayWorkspaceId, selected);
+            routes.set(route.gatewayWorkspaceId, route);
             this.writeRoutesToDisk(routes);
+            return route;
         });
-        if (!selected)
-            throw new Error("Failed to persist relayed Workspace route.");
         this.routes.set(selected.gatewayWorkspaceId, selected);
         return selected;
     }
-    deletePersistedRoute(workspaceId) {
-        this.updatePersistedRoutes((routes) => {
+    async deletePersistedRoute(workspaceId) {
+        await this.updatePersistedRoutes((routes) => {
             routes.delete(workspaceId);
         });
     }
-    updatePersistedRoutes(update) {
+    async updatePersistedRoutes(update) {
         mkdirSync(this.routeStateDir, { recursive: true });
-        this.withRouteFileLock(() => {
+        await withFileLock(`${this.routeStatePath}.lock`, () => {
             const routes = this.readRoutesFromDisk();
             update(routes);
             this.writeRoutesToDisk(routes);
@@ -418,43 +417,6 @@ export class RemoteWorkspaceRelay {
             rmSync(tempPath, { force: true });
         }
     }
-    withRouteFileLock(operation) {
-        const lockPath = `${this.routeStatePath}.lock`;
-        const deadline = Date.now() + ROUTE_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 > ROUTE_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 relayed workspace route lock: ${lockPath}`);
-                }
-                Atomics.wait(ROUTE_LOCK_SLEEP, 0, 0, ROUTE_LOCK_RETRY_MS);
-            }
-        }
-        try {
-            return operation();
-        }
-        finally {
-            rmSync(lockPath, { force: true });
-        }
-    }
     remoteByAlias(aliasInput) {
         const alias = aliasInput.trim();
         if (!alias)
@@ -522,7 +484,7 @@ export class RemoteWorkspaceRelay {
     }
     async refreshRemote(alias, remote, endpoint) {
         const refreshed = await refreshRemoteAuthentication(remote, endpoint);
-        writeForgeRelayRemote(alias, refreshed, this.authEnv);
+        await writeForgeRelayRemote(alias, refreshed, this.authEnv);
         return refreshed;
     }
     allocateGatewayWorkspaceId(routes = this.routes) {
@@ -533,114 +495,3 @@ export class RemoteWorkspaceRelay {
         return workspaceId;
     }
 }
-function assertRemoteToolSucceeded(alias, tool, result) {
-    if (result.isError !== true)
-        return;
-    throw new Error(`Remote ForgeRelay ${alias} ${tool} failed: ${toolResultText(result)}`);
-}
-function stringField(structured, field, label) {
-    const value = structured?.[field];
-    if (typeof value !== "string" || !value) {
-        throw new Error(`${label} did not include ${field}.`);
-    }
-    return value;
-}
-function copyStringField(source, target, field) {
-    const value = source[field];
-    if (typeof value === "string")
-        target[field] = value;
-}
-function copyBooleanField(source, target, field) {
-    const value = source[field];
-    if (typeof value === "boolean")
-        target[field] = value;
-}
-function copyNumberField(source, target, field) {
-    const value = source[field];
-    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
-        target[field] = value;
-}
-function safeTaskSummary(value) {
-    if (!value || typeof value !== "object")
-        return undefined;
-    const summary = value;
-    if (summary.level !== "summary" ||
-        summary.version !== 1 ||
-        typeof summary.revision !== "number" ||
-        !Number.isInteger(summary.revision) ||
-        summary.revision < 0 ||
-        !Array.isArray(summary.lists)) {
-        return undefined;
-    }
-    const lists = [];
-    for (const value of summary.lists) {
-        if (!value || typeof value !== "object")
-            return undefined;
-        const list = value;
-        if (typeof list.id !== "string" ||
-            typeof list.name !== "string" ||
-            (list.state !== "active" && list.state !== "archived") ||
-            typeof list.revision !== "number" || !Number.isInteger(list.revision) || list.revision <= 0 ||
-            typeof list.taskCount !== "number" || !Number.isInteger(list.taskCount) || list.taskCount < 0 ||
-            typeof list.unfinishedTaskCount !== "number" || !Number.isInteger(list.unfinishedTaskCount) || list.unfinishedTaskCount < 0) {
-            return undefined;
-        }
-        lists.push({
-            id: list.id,
-            name: list.name,
-            state: list.state,
-            revision: list.revision,
-            taskCount: list.taskCount,
-            unfinishedTaskCount: list.unfinishedTaskCount,
-        });
-    }
-    return {
-        level: "summary",
-        version: 1,
-        revision: summary.revision,
-        lists,
-    };
-}
-function toolResultText(result) {
-    return (result.content ?? [])
-        .filter((entry) => entry.type === "text")
-        .map((entry) => entry.text)
-        .join("\n") || "remote tool returned an error";
-}
-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),
-            }
-            : {}),
-    };
-}
-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)]));
-}
-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 });
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/workspaces/resources/skills.js

@@ -0,0 +1,285 @@
+import { existsSync, readdirSync, readFileSync, statSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, resolve, sep } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { markAdvertisedFileSourceActivated, resolveAdvertisedFileReadPath, } from "../../mcp/filesystem/advertised-files.js";
+import { expandHomePath, isPathInsideRoot } from "../../mcp/filesystem/roots.js";
+const SUBAGENT_DELEGATION_NAME = "subagent-delegation";
+const FRONTMATTER_DELIMITER = "---";
+export function effectiveSkillPaths(config, cwd) {
+    const defaultPathCandidates = [
+        join(homedir(), ".agents", "skills"),
+        resolve(cwd, ".agents", "skills"),
+        config.configSkillsDir,
+        join(config.agentDir, "skills"),
+    ];
+    const defaultPaths = defaultPathCandidates.filter((path) => path !== undefined && existsSync(path));
+    const seen = new Set();
+    return [...defaultPaths, ...config.skillPaths]
+        .map((path) => resolveSkillPath(path, cwd))
+        .filter((path) => {
+        if (seen.has(path))
+            return false;
+        seen.add(path);
+        return true;
+    });
+}
+function resolveSkillPath(path, cwd) {
+    return resolve(cwd, expandHomePath(path));
+}
+export function loadWorkspaceSkills(config, cwd) {
+    if (!config.skillsEnabled)
+        return { skills: [], diagnostics: [] };
+    const skills = [];
+    const diagnostics = [];
+    const winners = new Map();
+    for (const sourcePath of effectiveSkillPaths(config, cwd)) {
+        const candidates = discoverSkills(sourcePath, diagnostics);
+        for (const skill of candidates) {
+            const existing = winners.get(skill.name);
+            if (existing) {
+                diagnostics.push({
+                    type: "collision",
+                    message: `Skill '${skill.name}' from ${skill.filePath} was ignored because ${existing.skill.filePath} was loaded first.`,
+                    collision: {
+                        resourceType: "skill",
+                        name: skill.name,
+                        winnerPath: existing.skill.filePath,
+                        loserPath: skill.filePath,
+                        winnerSource: existing.source,
+                        loserSource: sourcePath,
+                    },
+                });
+                continue;
+            }
+            winners.set(skill.name, { skill, source: sourcePath });
+            skills.push(skill);
+        }
+    }
+    if (config.subagents)
+        return { skills, diagnostics };
+    return {
+        skills: skills.filter((skill) => skill.name !== SUBAGENT_DELEGATION_NAME),
+        diagnostics: diagnostics.filter((diagnostic) => {
+            const collision = diagnostic.collision;
+            return !(collision?.resourceType === "skill" && collision.name === SUBAGENT_DELEGATION_NAME);
+        }),
+    };
+}
+function discoverSkills(sourcePath, diagnostics) {
+    if (!existsSync(sourcePath))
+        return [];
+    let stats;
+    try {
+        stats = statSync(sourcePath);
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "warning",
+            message: `Unable to inspect skill path ${sourcePath}: ${errorMessage(error)}`,
+            path: sourcePath,
+        });
+        return [];
+    }
+    if (stats.isFile()) {
+        const skill = loadSkillFile(sourcePath, diagnostics);
+        return skill ? [skill] : [];
+    }
+    if (!stats.isDirectory())
+        return [];
+    const entry = join(sourcePath, "SKILL.md");
+    if (existsSync(entry)) {
+        const skill = loadSkillFile(entry, diagnostics);
+        return skill ? [skill] : [];
+    }
+    const skills = [];
+    for (const entryName of sortedDirectoryEntries(sourcePath, diagnostics)) {
+        const child = join(sourcePath, entryName);
+        let childStats;
+        try {
+            childStats = statSync(child);
+        }
+        catch (error) {
+            diagnostics.push({
+                type: "warning",
+                message: `Unable to inspect skill candidate ${child}: ${errorMessage(error)}`,
+                path: child,
+            });
+            continue;
+        }
+        if (childStats.isDirectory()) {
+            skills.push(...discoverSkills(child, diagnostics));
+            continue;
+        }
+        if (childStats.isFile() && extname(entryName).toLowerCase() === ".md") {
+            const skill = loadSkillFile(child, diagnostics);
+            if (skill)
+                skills.push(skill);
+        }
+    }
+    return skills;
+}
+function sortedDirectoryEntries(path, diagnostics) {
+    try {
+        return readdirSync(path).sort((left, right) => left.localeCompare(right));
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "warning",
+            message: `Unable to read skill directory ${path}: ${errorMessage(error)}`,
+            path,
+        });
+        return [];
+    }
+}
+function loadSkillFile(filePath, diagnostics) {
+    let content;
+    try {
+        content = readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "warning",
+            message: `Unable to read skill file ${filePath}: ${errorMessage(error)}`,
+            path: filePath,
+        });
+        return undefined;
+    }
+    let frontmatter = {};
+    try {
+        frontmatter = parseSkillFrontmatter(content);
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "error",
+            message: `Invalid skill frontmatter in ${filePath}: ${errorMessage(error)}`,
+            path: filePath,
+        });
+        return undefined;
+    }
+    const baseDir = dirname(filePath);
+    const name = normalizedSkillName(frontmatter.name, filePath);
+    if (!name) {
+        diagnostics.push({
+            type: "error",
+            message: `Skill ${filePath} has an invalid or empty name.`,
+            path: filePath,
+        });
+        return undefined;
+    }
+    const description = typeof frontmatter.description === "string"
+        ? frontmatter.description.trim()
+        : "";
+    return {
+        name,
+        description,
+        filePath: resolve(filePath),
+        baseDir: resolve(baseDir),
+        disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+    };
+}
+function parseSkillFrontmatter(content) {
+    const lines = content.replace(/^\uFEFF/, "").split(/\r?\n/);
+    if (lines[0]?.trim() !== FRONTMATTER_DELIMITER)
+        return {};
+    const end = lines.findIndex((line, index) => index > 0 && line.trim() === FRONTMATTER_DELIMITER);
+    if (end < 0)
+        throw new Error("opening '---' is missing a closing delimiter");
+    const parsed = parseYaml(lines.slice(1, end).join("\n"));
+    if (parsed === null || parsed === undefined)
+        return {};
+    if (typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("frontmatter must be a YAML mapping");
+    }
+    return parsed;
+}
+function normalizedSkillName(value, filePath) {
+    const explicit = typeof value === "string" ? value.trim() : "";
+    if (explicit)
+        return explicit;
+    if (basename(filePath).toLowerCase() === "skill.md")
+        return basename(dirname(filePath)).trim();
+    return basename(filePath, extname(filePath)).trim();
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function resolveSkillReadPath(skills, activatedSkillDirs, inputPath) {
+    const virtualRead = resolveVirtualSkillReadPath(skills, activatedSkillDirs, inputPath);
+    if (virtualRead)
+        return virtualRead;
+    const resolution = resolveAdvertisedFileReadPath(skills, activatedSkillDirs, inputPath);
+    if (!resolution)
+        return undefined;
+    return {
+        absolutePath: resolution.absolutePath,
+        skill: resolution.source,
+        isSkillFile: resolution.isEntryFile,
+    };
+}
+function resolveVirtualSkillReadPath(skills, activatedSkillDirs, inputPath) {
+    const prefix = "skills://";
+    if (!inputPath.startsWith(prefix))
+        return undefined;
+    const requested = inputPath.slice(prefix.length);
+    const slashIndex = requested.indexOf("/");
+    const encodedName = slashIndex === -1 ? requested : requested.slice(0, slashIndex);
+    if (!encodedName)
+        throw new Error(`Invalid skill URI: ${inputPath}`);
+    let name;
+    try {
+        name = decodeURIComponent(encodedName);
+    }
+    catch {
+        throw new Error(`Invalid skill URI: ${inputPath}`);
+    }
+    const skill = skills.find((candidate) => candidate.name === name);
+    if (!skill)
+        throw new Error(`Unknown advertised skill: ${name}`);
+    if (slashIndex === -1 || slashIndex === requested.length - 1) {
+        return {
+            absolutePath: resolve(skill.filePath),
+            skill,
+            isSkillFile: true,
+        };
+    }
+    const relativePart = requested.slice(slashIndex + 1);
+    const segments = relativePart.split("/").map((segment) => {
+        let decoded;
+        try {
+            decoded = decodeURIComponent(segment);
+        }
+        catch {
+            throw new Error(`Invalid skill URI: ${inputPath}`);
+        }
+        if (!decoded || decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\")) {
+            throw new Error(`Invalid skill URI: ${inputPath}`);
+        }
+        return decoded;
+    });
+    const baseDir = resolve(skill.baseDir);
+    if (!activatedSkillDirs.has(baseDir))
+        return undefined;
+    const absolutePath = resolve(baseDir, ...segments);
+    if (!isPathInsideRoot(absolutePath, baseDir)) {
+        throw new Error(`Skill resource is outside its skill directory: ${inputPath}`);
+    }
+    return {
+        absolutePath,
+        skill,
+        isSkillFile: false,
+    };
+}
+export function markSkillActivated(activatedSkillDirs, skill) {
+    markAdvertisedFileSourceActivated(activatedSkillDirs, skill);
+}
+export function formatPathForPrompt(path) {
+    const home = resolve(homedir());
+    const resolvedPath = resolve(path);
+    if (resolvedPath === home)
+        return "~";
+    if (resolvedPath.startsWith(`${home}${sep}`)) {
+        return `~/${resolvedPath.slice(home.length + 1).split(sep).join("/")}`;
+    }
+    return resolvedPath.split(sep).join("/");
+}

package/dist/{review-checkpoints.js → workspaces/review/review-checkpoints.js}

@@ -1,8 +1,8 @@
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { git, getGitEligibility, safeWorkspaceRefSegment } from "./git.js";
-const REVIEW_REF_PREFIX = "refs/devspace/review";
+import { git, getGitEligibility, safeWorkspaceRefSegment } from "../git/git.js";
+const REVIEW_REF_PREFIX = "refs/forgerelay/review";
 const DEFAULT_MAX_REVIEW_WORKSPACE_STATES = 128;
 export function createReviewCheckpointManager(options = {}) {
     const maxWorkspaceStates = options.maxWorkspaceStates ?? DEFAULT_MAX_REVIEW_WORKSPACE_STATES;