@akira-tl/forgerelay 0.8.9 → 0.9.0

package/dist/workspaces/context.js

@@ -4,6 +4,7 @@ import { dirname, join, relative, resolve, sep } from "node:path";
 import { markCapabilityGuideActivated, resolveCapabilityGuideReadPath, } from "../mcp/server/core/capabilities.js";
 import { assertAllowedPath, isPathInsideRoot, resolveAllowedPath, } from "../mcp/filesystem/roots.js";
 import { loadWorkspaceSkills, markSkillActivated, resolveSkillReadPath, } from "./resources/skills.js";
+import { WorkspaceResourceMonitor, } from "./resources/resource-monitor.js";
 const INITIAL_INSTRUCTION_DISCOVERY_DEPTH = 1;
 const CONTEXT_FILE_NAMES = new Set(["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"]);
 const SKIPPED_CONTEXT_DIRS = new Set([
@@ -25,6 +26,7 @@ const SKIPPED_CONTEXT_DIRS = new Set([
  */
 export class WorkspaceContextService {
     config;
+    resourceMonitor = new WorkspaceResourceMonitor();
     constructor(config) {
         this.config = config;
     }
@@ -87,6 +89,7 @@ export class WorkspaceContextService {
     markReadPathLoaded(workspace, readPath) {
         if (readPath.skillRead?.isSkillFile) {
             markSkillActivated(workspace.activatedSkillDirs, readPath.skillRead.skill);
+            this.resourceMonitor.markSkillActivated(workspace.id, readPath.skillRead.skill.filePath);
         }
         if (readPath.capabilityGuideRead?.isGuideFile) {
             markCapabilityGuideActivated(workspace.activatedCapabilityGuideDirs, readPath.capabilityGuideRead.guide);
@@ -198,8 +201,40 @@ export class WorkspaceContextService {
             await this.discoverInstructionTree(workspace, directory, 0);
             loaded.push(...await this.loadKnownInstructionsInDirectory(workspace, directory));
         }
+        for (const file of loaded) {
+            this.resourceMonitor.trackLoadedInstruction(workspace.id, workspace.root, file.path);
+        }
         return loaded;
     }
+    trackWorkspaceResources(workspace, agentsFiles, availableAgentsFiles) {
+        this.resourceMonitor.trackWorkspace({
+            workspaceId: workspace.id,
+            root: workspace.root,
+            loadedInstructions: agentsFiles.map((file) => file.path),
+            availableInstructions: availableAgentsFiles.map((file) => file.path),
+            skills: workspace.skills.map((skill) => ({
+                name: skill.name,
+                filePath: skill.filePath,
+                baseDir: skill.baseDir,
+                activated: workspace.activatedSkillDirs.has(resolve(skill.baseDir)),
+            })),
+        });
+    }
+    claimResourceUpdates(workspaceId, conversationScopeId) {
+        return this.resourceMonitor.claim(workspaceId, conversationScopeId);
+    }
+    acknowledgeResourceUpdates(workspaceId, conversationScopeId) {
+        this.resourceMonitor.acknowledge(workspaceId, conversationScopeId);
+    }
+    resourceUpdatesCurrent(workspaceId, conversationScopeId) {
+        return this.resourceMonitor.isCurrentForScope(workspaceId, conversationScopeId);
+    }
+    forgetWorkspaceResources(workspaceId) {
+        this.resourceMonitor.forgetWorkspace(workspaceId);
+    }
+    pruneWorkspaceResources(activeWorkspaceIds) {
+        this.resourceMonitor.pruneWorkspaces(activeWorkspaceIds);
+    }
     async discoverInstructionTree(workspace, directory, remainingDepth) {
         const resolvedDirectory = resolve(directory);
         if (workspace.scannedInstructionDirs.has(resolvedDirectory))

package/dist/workspaces/git/worktree-recovery.js

@@ -0,0 +1,189 @@
+import { realpath, stat } from "node:fs/promises";
+import { platform } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { assertAllowedPath } from "../../mcp/filesystem/roots.js";
+import { git } from "./git.js";
+export async function inspectManagedWorktreeRecovery(session, config) {
+    if (session.status !== "active" ||
+        session.mode !== "worktree" ||
+        !session.managed)
+        return undefined;
+    const backing = await directoryState(session.root, [config.worktreeRoot]);
+    const source = await sourceState(session.sourceRoot, config.allowedRoots);
+    const conditions = [];
+    if (source === "missing")
+        conditions.push("source-missing");
+    else if (source === "unavailable")
+        conditions.push("source-unavailable");
+    if (backing === "missing")
+        conditions.push("backing-missing");
+    if (source !== "available" || !session.sourceRoot) {
+        return {
+            classification: "manual-intervention",
+            conditions,
+            backing,
+            source,
+            gitRegistration: "unavailable",
+            managedBranch: "unknown",
+            targetBranch: "unknown",
+            backingBranch: "unavailable",
+        };
+    }
+    const sourceRoot = assertAllowedPath(session.sourceRoot, config.allowedRoots);
+    const [managedBranch, targetBranch, registration] = await Promise.all([
+        branchState(sourceRoot, session.branch),
+        branchState(sourceRoot, session.targetBranch),
+        registrationState(sourceRoot, session.root),
+    ]);
+    if (managedBranch === "missing")
+        conditions.push("managed-branch-missing");
+    if (targetBranch === "missing")
+        conditions.push("target-branch-missing");
+    if (registration === "stale")
+        conditions.push("git-registration-stale");
+    else if (registration === "missing")
+        conditions.push("git-registration-missing");
+    else if (registration === "unavailable")
+        conditions.push("git-registration-unavailable");
+    const backingBranch = backing === "present"
+        ? await backingBranchState(session.root, session.branch)
+        : "unavailable";
+    if (backingBranch === "mismatched")
+        conditions.push("branch-mismatch");
+    const recoverable = backing === "missing" &&
+        managedBranch === "present" &&
+        targetBranch === "present" &&
+        (registration === "stale" || registration === "missing") &&
+        conditions.every((condition) => condition === "backing-missing" ||
+            condition === "git-registration-stale" ||
+            condition === "git-registration-missing");
+    return {
+        classification: conditions.length === 0
+            ? "healthy"
+            : recoverable
+                ? "recoverable"
+                : "manual-intervention",
+        conditions,
+        backing,
+        source,
+        gitRegistration: registration,
+        managedBranch,
+        targetBranch,
+        backingBranch,
+    };
+}
+async function directoryState(path, allowedRoots) {
+    const allowedPath = assertAllowedPath(path, allowedRoots);
+    try {
+        return (await stat(allowedPath)).isDirectory() ? "present" : "missing";
+    }
+    catch (error) {
+        if (isMissingPath(error))
+            return "missing";
+        throw error;
+    }
+}
+async function sourceState(sourceRoot, allowedRoots) {
+    if (!sourceRoot)
+        return "unavailable";
+    let sourcePath;
+    try {
+        sourcePath = assertAllowedPath(sourceRoot, allowedRoots);
+    }
+    catch {
+        return "unavailable";
+    }
+    try {
+        if (!(await stat(sourcePath)).isDirectory())
+            return "missing";
+    }
+    catch (error) {
+        return isMissingPath(error) ? "missing" : "unavailable";
+    }
+    try {
+        const gitRoot = (await git(sourcePath, ["rev-parse", "--show-toplevel"])).stdout.trim();
+        const [canonicalGitRoot, canonicalSource] = await Promise.all([realpath(gitRoot), realpath(sourcePath)]);
+        return pathKey(canonicalGitRoot) === pathKey(canonicalSource) ? "available" : "unavailable";
+    }
+    catch {
+        return "unavailable";
+    }
+}
+async function branchState(sourceRoot, branch) {
+    if (!branch)
+        return "missing";
+    try {
+        await git(sourceRoot, ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`]);
+        return "present";
+    }
+    catch {
+        return "missing";
+    }
+}
+async function registrationState(sourceRoot, worktreePath) {
+    let registrations;
+    try {
+        registrations = parseWorktreeRegistrations((await git(sourceRoot, ["worktree", "list", "--porcelain"])).stdout);
+    }
+    catch {
+        return "unavailable";
+    }
+    const worktreeKey = await registrationPathKey(worktreePath);
+    for (const registration of registrations) {
+        if (await registrationPathKey(registration.path) !== worktreeKey)
+            continue;
+        return registration.prunable ? "stale" : "registered";
+    }
+    return "missing";
+}
+async function backingBranchState(worktreeRoot, expectedBranch) {
+    if (!expectedBranch)
+        return "mismatched";
+    try {
+        const actual = (await git(worktreeRoot, ["symbolic-ref", "--quiet", "--short", "HEAD"])).stdout.trim();
+        return actual === expectedBranch ? "matching" : "mismatched";
+    }
+    catch {
+        return "mismatched";
+    }
+}
+function parseWorktreeRegistrations(output) {
+    return output
+        .trim()
+        .split(/\n\n+/)
+        .map((block) => {
+        const lines = block.split("\n");
+        const path = lines.find((line) => line.startsWith("worktree "))?.slice("worktree ".length);
+        if (!path)
+            return undefined;
+        return {
+            path,
+            prunable: lines.some((line) => line.startsWith("prunable ")),
+        };
+    })
+        .filter((entry) => entry !== undefined);
+}
+async function registrationPathKey(path) {
+    const resolved = resolve(path);
+    try {
+        return pathKey(await realpath(resolved));
+    }
+    catch (error) {
+        if (!isMissingPath(error))
+            return pathKey(resolved);
+        try {
+            return pathKey(join(await realpath(dirname(resolved)), basename(resolved)));
+        }
+        catch {
+            return pathKey(resolved);
+        }
+    }
+}
+function pathKey(path) {
+    const resolved = resolve(path);
+    return platform() === "win32" ? resolved.toLowerCase() : resolved;
+}
+function isMissingPath(error) {
+    return error instanceof Error && "code" in error &&
+        (error.code === "ENOENT" || error.code === "ENOTDIR");
+}

package/dist/workspaces/inventory.js

@@ -1,6 +1,7 @@
 import { basename, resolve } from "node:path";
 import { assertAllowedPath } from "../mcp/filesystem/roots.js";
 import { canonicalPath } from "./paths.js";
+import { inspectManagedWorktreeRecovery } from "./git/worktree-recovery.js";
 const WORKSPACE_STALE_REMINDER_MS = 2 * 24 * 60 * 60 * 1_000;
 /** Build bounded read-only projections over persistent Workspace sessions. */
 export class WorkspaceInventoryService {
@@ -84,11 +85,12 @@ export class WorkspaceInventoryService {
     }
     async inventoryEntryForSession(session, now, current) {
         const rootValid = await this.sessions.validSessionRoot(session) !== undefined;
+        const recovery = await inspectManagedWorktreeRecovery(session, this.config);
         const lastUsedAt = Date.parse(session.lastUsedAt);
         const idleMs = Number.isFinite(lastUsedAt) ? Math.max(0, now - lastUsedAt) : 0;
         const state = session.status !== "active"
             ? "closed"
-            : !rootValid
+            : !rootValid || (recovery !== undefined && recovery.classification !== "healthy")
                 ? "invalid"
                 : idleMs >= WORKSPACE_STALE_REMINDER_MS
                     ? "stale"
@@ -109,6 +111,7 @@ export class WorkspaceInventoryService {
             lastUsedAt: session.lastUsedAt,
             idleMs,
             rootValid,
+            ...(recovery ? { recovery } : {}),
             current,
         };
     }

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

@@ -25,6 +25,42 @@ export function copyNumberField(source, target, field) {
     if (typeof value === "number" && Number.isFinite(value) && value >= 0)
         target[field] = value;
 }
+export function safeManagedWorktreeRecovery(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const recovery = value;
+    const classifications = new Set(["healthy", "recoverable", "manual-intervention"]);
+    const conditions = new Set([
+        "backing-missing",
+        "managed-branch-missing",
+        "git-registration-stale",
+        "git-registration-missing",
+        "git-registration-unavailable",
+        "branch-mismatch",
+        "source-missing",
+        "source-unavailable",
+        "target-branch-missing",
+    ]);
+    if (typeof recovery.classification !== "string" || !classifications.has(recovery.classification) ||
+        !Array.isArray(recovery.conditions) || recovery.conditions.some((condition) => typeof condition !== "string" || !conditions.has(condition)) ||
+        (recovery.backing !== "present" && recovery.backing !== "missing") ||
+        (recovery.source !== "available" && recovery.source !== "missing" && recovery.source !== "unavailable") ||
+        (recovery.gitRegistration !== "registered" && recovery.gitRegistration !== "stale" && recovery.gitRegistration !== "missing" && recovery.gitRegistration !== "unavailable") ||
+        (recovery.managedBranch !== "present" && recovery.managedBranch !== "missing" && recovery.managedBranch !== "unknown") ||
+        (recovery.targetBranch !== "present" && recovery.targetBranch !== "missing" && recovery.targetBranch !== "unknown") ||
+        (recovery.backingBranch !== "matching" && recovery.backingBranch !== "mismatched" && recovery.backingBranch !== "unavailable"))
+        return undefined;
+    return {
+        classification: recovery.classification,
+        conditions: [...recovery.conditions],
+        backing: recovery.backing,
+        source: recovery.source,
+        gitRegistration: recovery.gitRegistration,
+        managedBranch: recovery.managedBranch,
+        targetBranch: recovery.targetBranch,
+        backingBranch: recovery.backingBranch,
+    };
+}
 export function safeTaskSummary(value) {
     if (!value || typeof value !== "object")
         return undefined;

package/dist/workspaces/relay/transport/remote-transport.js

@@ -27,15 +27,42 @@ export async function readRemoteOwnerToken(sshRoute) {
     const result = await runSshCommand([
         ...prefix,
         target,
-        "forgerelay",
-        "auth",
-        "__owner-token",
+        remoteOwnerTokenCommand(),
     ]);
     const token = result.stdout.trim();
     if (!token)
         throw new Error("SSH owner-token command returned an empty token.");
     return token;
 }
+function remoteOwnerTokenCommand() {
+    const script = [
+        "set -u",
+        "try_forgerelay() {",
+        "  candidate=\"$1\"",
+        "  [ -x \"$candidate\" ] || return 1",
+        "  token=$(\"$candidate\" auth __owner-token 2>/dev/null) || token=",
+        "  if [ -z \"$token\" ]; then",
+        "    sibling_node=$(dirname \"$candidate\")/node",
+        "    [ -x \"$sibling_node\" ] || return 1",
+        "    token=$(\"$sibling_node\" \"$candidate\" auth __owner-token 2>/dev/null) || return 1",
+        "  fi",
+        "  [ -n \"$token\" ] || return 1",
+        "  printf '%s\\n' \"$token\"",
+        "  exit 0",
+        "}",
+        "path_candidate=$(command -v forgerelay 2>/dev/null || true)",
+        "[ -n \"$path_candidate\" ] && try_forgerelay \"$path_candidate\"",
+        "for candidate in \"$HOME/.local/bin/forgerelay\" \"$HOME/.npm-global/bin/forgerelay\" \"$HOME/.volta/bin/forgerelay\" \"$HOME/.local/share/pnpm/forgerelay\" \"$HOME/.bun/bin/forgerelay\" \"$HOME\"/.nvm/versions/node/*/bin/forgerelay; do",
+        "  try_forgerelay \"$candidate\"",
+        "done",
+        "printf '%s\\n' 'ForgeRelay CLI was not found in the non-interactive SSH environment or supported user-local install paths.' >&2",
+        "exit 127",
+    ].join("\n");
+    return `sh -c ${shellQuote(script)}`;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\"'\"'`)}'`;
+}
 export async function openRemoteServiceEndpoint(target, sshRoute) {
     if (!sshRoute) {
         return { endpoint: target, close: async () => undefined };

package/dist/workspaces/relay/workspace-relay.js

@@ -7,7 +7,7 @@ import { RemoteMcpConnectionPool } from "./transport/remote-mcp-connection-pool.
 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";
+import { assertRemoteToolSucceeded, copyBooleanField, copyNumberField, copyStringField, errorMessage, remapToolResultWorkspaceId, replaceExactWorkspaceId, safeManagedWorktreeRecovery, safeTaskSummary, sanitizedRemoteError, stringField, toolResultText, } from "./result-support.js";
 export class RemoteWorkspaceRelay {
     routes = new Map();
     turnRoutes = new Map();
@@ -77,6 +77,9 @@ export class RemoteWorkspaceRelay {
         copyStringField(remoteInspection, projection, "lastUsedAt");
         copyNumberField(remoteInspection, projection, "idleMs");
         copyBooleanField(remoteInspection, projection, "rootValid");
+        const recovery = safeManagedWorktreeRecovery(remoteInspection.recovery);
+        if (recovery)
+            projection.recovery = recovery;
         const taskSummary = safeTaskSummary(remoteInspection.taskSummary);
         if (taskSummary)
             projection.taskSummary = taskSummary;