Files
Netcatty/electron/bridges/mcpServerBridge/capabilityRpcDispatch.cjs
T
GOUKI9999 b496b00d2f feat: bounded recovery for scoped disconnected sessions (#3935)
Contributor GOUKI9999 session_reconnect/session_recover. Maintainer gate fix: do not report ready while still offline/connecting (pending instead); connected keeps advisory shellReady; regenerate capability tool specs. Unit tests 12/12. Electron smoke PASS (SSH shell path). Residual P2 hung-worker readiness left timeout-bounded. No release.
2026-10-29 19:32:02 -07:00

225 lines
9.7 KiB
JavaScript

"use strict";
const { CAPABILITY_STATUS, CAPABILITY_SURFACES, PERMISSION_MODES } = require("../../capabilities/constants.cjs");
const { getCapabilityByRpcMethod } = require("../../capabilities/registry.cjs");
const { getMcpToolNameForRpcMethod } = require("../../capabilities/adapters/mcpAdapter.cjs");
const { createVaultService } = require("../../capabilities/services/vaultService.cjs");
const { createPortForwardService } = require("../../capabilities/services/portforwardService.cjs");
const { createSessionService } = require("../../capabilities/services/sessionService.cjs");
const UNROUTED = Symbol("capability-rpc-unrouted");
const SERVICE_BINDINGS = Object.freeze({
"vault.host.get": { domain: "vault", method: "getHost" },
"vault.host.list": { domain: "vault", method: "listHosts" },
"vault.host.open": { domain: "vault", method: "openHost" },
"vault.hosts.create": { domain: "vault", method: "createHosts" },
"vault.host.update": { domain: "vault", method: "updateHost" },
"vault.host.delete": { domain: "vault", method: "deleteHost" },
"vault.host.import": { domain: "vault", method: "importHosts" },
"vault.host.notes.get": { domain: "vault", method: "getHostNotes" },
"vault.host.notes.set": { domain: "vault", method: "setHostNotes" },
"vault.note.list": { domain: "vault", method: "listNotes" },
"vault.note.get": { domain: "vault", method: "getNote" },
"vault.note.create": { domain: "vault", method: "createNote" },
"vault.note.update": { domain: "vault", method: "updateNote" },
"vault.note.delete": { domain: "vault", method: "deleteNote" },
"vault.note.import": { domain: "vault", method: "importNotes" },
"vault.identity.list": { domain: "vault", method: "listIdentities" },
"vault.proxyProfile.list": { domain: "vault", method: "listProxyProfiles" },
"vault.group.list": { domain: "vault", method: "listGroups" },
"vault.group.create": { domain: "vault", method: "createGroup" },
"vault.group.update": { domain: "vault", method: "updateGroup" },
"vault.group.delete": { domain: "vault", method: "deleteGroup" },
"vault.snippets.list": { domain: "vault", method: "listSnippets" },
"vault.snippets.get": { domain: "vault", method: "getSnippet" },
"vault.snippets.run": { domain: "vault", method: "runSnippet" },
"vault.snippets.create": { domain: "vault", method: "createSnippet" },
"vault.snippets.update": { domain: "vault", method: "updateSnippet" },
"vault.snippets.delete": { domain: "vault", method: "deleteSnippet" },
"vault.scripts.list": { domain: "vault", method: "listScripts" },
"vault.scripts.get": { domain: "vault", method: "getScript" },
"vault.scripts.create": { domain: "vault", method: "createScript" },
"vault.scripts.update": { domain: "vault", method: "updateScript" },
"vault.scripts.delete": { domain: "vault", method: "deleteScript" },
"vault.scripts.run": { domain: "vault", method: "runScript" },
"vault.scripts.reference": { domain: "vault", method: "getScriptReference" },
"vault.scripts.runs.list": { domain: "vault", method: "listScriptRuns" },
"vault.scripts.run.stop": { domain: "vault", method: "stopScriptRun" },
"vault.scripts.run.pause": { domain: "vault", method: "pauseScriptRun" },
"vault.scripts.run.resume": { domain: "vault", method: "resumeScriptRun" },
"vault.scripts.targets.set": { domain: "vault", method: "setScriptTargets" },
"vault.host.connectScripts.list": { domain: "vault", method: "listHostConnectScripts" },
"vault.host.connectScripts.set": { domain: "vault", method: "setHostConnectScripts" },
"portforward.rules.list": { domain: "portforward", method: "listRules" },
"portforward.rules.create": { domain: "portforward", method: "createRule" },
"portforward.rules.update": { domain: "portforward", method: "updateRule" },
"portforward.rules.duplicate": { domain: "portforward", method: "duplicateRule" },
"portforward.rules.delete": { domain: "portforward", method: "deleteRule" },
"portforward.tunnels.list": { domain: "portforward", method: "listTunnels" },
"portforward.start": { domain: "portforward", method: "start" },
"portforward.stop": { domain: "portforward", method: "stop" },
"session.close": { domain: "session", method: "close" },
"session.reconnect": { domain: "session", method: "reconnect" },
"session.recover": { domain: "session", method: "recover" },
});
function resolveCapabilitySurface(rpcMethod) {
for (const surface of [
CAPABILITY_SURFACES.PUBLIC,
CAPABILITY_SURFACES.GLOBAL,
CAPABILITY_SURFACES.BUILTIN,
]) {
if (rpcMethod.startsWith("netcatty/") && surface !== CAPABILITY_SURFACES.BUILTIN) {
continue;
}
const capability = getCapabilityByRpcMethod(rpcMethod, surface);
if (capability) {
return { capability, surface };
}
}
return null;
}
function createCapabilityRpcDispatcher(deps) {
const {
invokeVaultAgent,
evaluatePermissionWithGrants,
isChatSessionCancelled,
requestApprovalFromRenderer,
USER_DENIED_MESSAGE,
} = deps;
const vaultService = createVaultService({ invokeVaultAgent });
const portforwardService = createPortForwardService({
invokeVaultAgent,
listPortForwards: deps.listPortForwards,
});
const sessionService = deps.sessionService || createSessionService({
invokeSessionAgent: invokeVaultAgent,
validateClose: deps.validateSessionClose,
validateReconnect: deps.validateSessionReconnect,
inspectRecovery: deps.inspectSessionRecovery,
beforeClose: deps.beforeSessionClose,
afterClose: deps.afterSessionClose,
onClosed: deps.onSessionClosed,
});
const services = {
vault: vaultService,
portforward: portforwardService,
session: sessionService,
};
return async function dispatchCapabilityRpc(rpcMethod, params = {}, approvalContext = {}) {
if (typeof rpcMethod !== "string" || rpcMethod.startsWith("netcatty/")) {
return UNROUTED;
}
const resolved = resolveCapabilitySurface(rpcMethod);
if (!resolved) {
return UNROUTED;
}
const { capability, surface } = resolved;
if (capability.status !== CAPABILITY_STATUS.IMPLEMENTED) {
return {
ok: false,
code: "CAPABILITY_NOT_IMPLEMENTED",
error: `Capability "${capability.id}" is not implemented yet.`,
};
}
const binding = SERVICE_BINDINGS[capability.id];
if (!binding) {
return UNROUTED;
}
// Session lifecycle operations execute against params.sessionId. host.open instead
// targets its requested vault host; other vault/script operations must not
// borrow an unrelated session's host grant.
let approvalTarget = ["session.close", "session.reconnect", "session.recover"].includes(capability.id)
? (deps.getApprovalTarget?.(params) || null)
: null;
if (capability.id === "vault.host.open" && deps.permissionMode === PERMISSION_MODES.CONFIRM) {
const requestedHostId = typeof params?.hostId === "string" ? params.hostId.trim() : "";
let lookup = null;
if (requestedHostId) {
try {
lookup = await vaultService.getHost({ hostId: requestedHostId });
} catch {
// The metadata lookup is best-effort; without it, approval cannot
// offer a persistent host grant.
}
}
const host = lookup?.host?.id === requestedHostId ? lookup.host : null;
approvalTarget = {
sessionId: "",
hostId: host && host.ephemeral !== true && host.protocol !== "serial" && host.protocol !== "local"
? requestedHostId
: "",
label: host?.label || host?.hostname || requestedHostId,
hostname: host?.hostname || "",
};
}
const permission = deps.isDelegatedApproval?.(approvalContext)
? { allowed: !isChatSessionCancelled(params?.chatSessionId), requiresApproval: false }
: evaluatePermissionWithGrants({
rpcMethod,
surface,
permissionMode: deps.permissionMode,
params,
context: {
chatSessionCancelled: isChatSessionCancelled(params?.chatSessionId),
hostId: approvalTarget?.hostId,
},
}, deps.permissionGrantsSnapshot);
if (!permission.allowed) {
return { ok: false, error: permission.error };
}
if (permission.requiresApproval && !deps.hasSessionApproval?.(approvalContext.externalSocket)) {
const { chatSessionId, ...toolArgs } = params || {};
const toolName = getMcpToolNameForRpcMethod(rpcMethod, surface)
|| capability.surfaces?.[CAPABILITY_SURFACES.PUBLIC]?.mcpTool
|| capability.id;
const approved = await requestApprovalFromRenderer(toolName, toolArgs, chatSessionId, {
...approvalContext,
target: approvalTarget,
});
if (!approved) {
return { ok: false, error: USER_DENIED_MESSAGE };
}
}
const service = services[binding.domain];
const handler = service?.[binding.method];
if (typeof handler !== "function") {
return {
ok: false,
error: `Capability handler "${capability.id}" is unavailable.`,
};
}
const hostOpenGeneration = capability.id === "vault.host.open"
? deps.captureHostOpenScope?.(params?.chatSessionId)
: null;
approvalContext.beforeExecute?.();
const result = await handler(params, approvalContext);
if (capability.id === "vault.host.open" && result?.ok !== false && result?.sessionId) {
const bound = await deps.onHostOpened?.(params?.chatSessionId, result.sessionId, hostOpenGeneration, result);
if (bound === false) {
return { ok: false, code: "SESSION_SCOPE_BIND_FAILED", sessionId: result.sessionId, error: "Host opened but its session could not be bound to the requesting chat scope." };
}
if (bound === true) return { ...result, scopeBound: true };
}
return result;
};
}
module.exports = {
UNROUTED,
createCapabilityRpcDispatcher,
SERVICE_BINDINGS,
};