Files
Netcatty/electron/plugins/runtime/runtimePeer.mjs
T

357 lines
12 KiB
JavaScript

import {
CancellationTokenSource,
DisposableStore,
PluginError,
pluginErrorToRpcError,
} from "@netcatty/plugin-sdk";
import { createMessagePortStreamEnvelope } from "@netcatty/plugin-contract";
const RPC_ERRORS = {
methodNotFound: -32601,
invalidParams: -32602,
internal: -32603,
cancelled: -32001,
unsupported: -32012,
};
function messageData(value) {
return value && typeof value === "object" && "data" in value ? value.data : value;
}
function createTransportAdapter(port) {
const listeners = new Set();
const handle = (event) => {
const value = messageData(event);
for (const listener of listeners) listener(value);
};
if (typeof port.addEventListener === "function") port.addEventListener("message", handle);
else port.on("message", handle);
port.start?.();
return {
post(message, transfer = []) {
port.postMessage(message, transfer);
},
onMessage(listener) {
listeners.add(listener);
return () => listeners.delete(listener);
},
close() {
listeners.clear();
port.close?.();
},
};
}
function makeRpcFailure(id, code, message, data) {
return {
jsonrpc: "2.0",
id,
error: { code, message, ...(data === undefined ? {} : { data }) },
};
}
function cancelUnhandledStream(transport, message) {
const keys = Reflect.ownKeys(message);
if (keys.some((key) => typeof key !== "string" || (key !== "frame" && key !== "transfer"))) {
throw new TypeError("Plugin stream envelope contains unknown properties");
}
for (const key of keys) {
const descriptor = Object.getOwnPropertyDescriptor(message, key);
if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
throw new TypeError("Plugin stream envelope must contain enumerable data properties");
}
}
const envelope = createMessagePortStreamEnvelope(message.frame, message.transfer);
if (envelope.frame.kind !== "open") {
throw new Error(`Unknown incoming plugin stream: ${envelope.frame.streamId}`);
}
transport.post(createMessagePortStreamEnvelope({
streamId: envelope.frame.streamId,
sequence: 1,
kind: "cancel",
}));
}
function normalizeError(error) {
if (error instanceof PluginError) {
return pluginErrorToRpcError(error);
}
return { code: RPC_ERRORS.internal, message: "Plugin operation failed" };
}
function createHostClient(transport) {
let nextId = 0;
const pending = new Map();
function accept(message) {
if (!message || typeof message !== "object" || !Object.hasOwn(message, "id")) return false;
if (!Object.hasOwn(message, "result") && !Object.hasOwn(message, "error")) return false;
const request = pending.get(`${typeof message.id}:${String(message.id)}`);
if (!request) return false;
pending.delete(`${typeof message.id}:${String(message.id)}`);
if (message.error) {
request.reject(new PluginError(
message.error.data?.pluginCode ?? "unknown",
message.error.message,
message.error.data?.details,
));
} else request.resolve(message.result);
return true;
}
function request(method, params, options = {}) {
const id = nextId;
nextId = nextId === Number.MAX_SAFE_INTEGER ? 0 : nextId + 1;
return new Promise((resolve, reject) => {
pending.set(`${typeof id}:${String(id)}`, { resolve, reject });
transport.post({
jsonrpc: "2.0",
id,
method,
params,
...(options.deadlineMs === undefined ? {} : { deadlineMs: options.deadlineMs }),
});
});
}
function notify(method, params) {
transport.post({ jsonrpc: "2.0", method, params });
}
function close() {
const error = new PluginError("unavailable", "Plugin host disconnected");
for (const request of pending.values()) request.reject(error);
pending.clear();
}
return { accept, request, notify, close };
}
function assertStorageKey(key) {
if (typeof key !== "string" || key.length < 1 || key.length > 256 || key.includes("\0")) {
throw new PluginError("invalid_argument", "Plugin storage key is invalid");
}
return key;
}
function assertCredentialRef(credential) {
if (
!credential
|| typeof credential !== "object"
|| (credential.kind !== "secret" && credential.kind !== "credential")
|| typeof credential.id !== "string"
|| credential.id.length < 16
|| credential.id.length > 256
) throw new PluginError("invalid_argument", "Credential reference is invalid");
if (
credential.kind === "secret"
&& (
typeof credential.key !== "string"
|| credential.key.length < 1
|| credential.key.length > 256
|| credential.key.includes("\0")
)
) throw new PluginError("invalid_argument", "Credential reference is invalid");
return credential.kind === "secret"
? { kind: "secret", id: credential.id, key: credential.key }
: { kind: "credential", id: credential.id };
}
function forwardedDeadline(value, maximum) {
return Number.isSafeInteger(value) && value >= 1 && value <= maximum ? value : undefined;
}
function assertCompanionId(companionId) {
if (typeof companionId !== "string" || companionId.length < 5 || companionId.length > 192) {
throw new PluginError("invalid_argument", "Companion ID is invalid");
}
return companionId;
}
function createPluginContext(config, client) {
const subscriptions = new DisposableStore();
const storage = {
get: (key) => client.request("storage.get", { key: assertStorageKey(key) })
.then((result) => result?.found ? result.value : undefined),
set: (key, value) => client.request("storage.set", { key: assertStorageKey(key), value })
.then(() => undefined),
delete: (key) => client.request("storage.delete", { key: assertStorageKey(key) })
.then(() => undefined),
keys: () => client.request("storage.keys", {}).then((result) => result?.keys ?? []),
};
const secrets = {
get: (key) => client.request("secrets.get", { key: assertStorageKey(key) })
.then((result) => result?.found ? result.secret : undefined),
set: (key, value) => client.request("secrets.set", {
key: assertStorageKey(key),
value,
}).then((result) => result.secret),
delete: (key) => client.request("secrets.delete", { key: assertStorageKey(key) })
.then(() => undefined),
};
const credentials = {
createLease: (secret, options) => client.request("credentials.createLease", {
secret: assertCredentialRef(secret),
operationId: options?.operationId,
purpose: options?.purpose,
...(options?.ttlMs === undefined ? {} : { ttlMs: options.ttlMs }),
}),
};
const network = {
request: (request) => client.request("network.request", request, {
deadlineMs: forwardedDeadline(request?.timeoutMs, 300_000),
}),
};
const filesystem = {
readFile: (filePath, options = {}) => client.request("filesystem.readFile", {
path: filePath,
...options,
}).then((result) => result.data),
writeFile: (filePath, data, options = {}) => client.request("filesystem.writeFile", {
path: filePath,
data,
...options,
}).then(() => undefined),
stat: (filePath) => client.request("filesystem.stat", { path: filePath }),
readDirectory: (directoryPath) => client.request("filesystem.readDirectory", { path: directoryPath })
.then((result) => result.entries),
};
const companions = {
start: async (companionId) => {
const result = await client.request("companion.start", {
companionId: assertCompanionId(companionId),
});
let stopped = false;
let stopPromise = null;
const stop = () => {
if (stopped) return Promise.resolve();
if (stopPromise) return stopPromise;
stopPromise = client.request("companion.stop", { handleId: result.handleId })
.then(() => { stopped = true; })
.finally(() => { stopPromise = null; });
return stopPromise;
};
return Object.freeze({
id: result.handleId,
request: (method, params, options = {}) => client.request(
"companion.request",
{
handleId: result.handleId,
method,
...(params === undefined ? {} : { params }),
...options,
},
{ deadlineMs: forwardedDeadline(options.timeoutMs, 60_000) },
),
stop,
dispose() { void stop().catch(() => {}); },
});
},
};
const logger = Object.fromEntries(["debug", "info", "warn", "error"].map((level) => [
level,
(message, fields) => client.notify("log.write", {
level,
message: String(message).slice(0, 2_048),
...(fields === undefined ? {} : { fields }),
}),
]));
return {
pluginId: config.pluginId,
netcattyVersion: config.netcattyVersion,
apiVersion: config.apiVersion,
enabledFeatures: new Set(config.enabledFeatures),
subscriptions,
storage,
secrets,
credentials,
network,
filesystem,
companions,
logger,
};
}
export async function startPluginRuntime({ port, config, loadPlugin }) {
const transport = createTransportAdapter(port);
const client = createHostClient(transport);
const cancellation = new Map();
let plugin;
let context;
let activated = false;
let deactivated = false;
const pluginModule = await loadPlugin(config.entryUrl);
plugin = pluginModule?.default;
if (!plugin || typeof plugin.activate !== "function") {
throw new Error("Plugin entrypoint must default-export a plugin with activate(context)");
}
async function handleRequest(message) {
if (message.method === "plugin.initialize") {
if (context) throw new PluginError("failed_precondition", "Plugin is already initialized");
context = createPluginContext(config, client);
return {
pluginId: config.pluginId,
pluginVersion: config.pluginVersion,
apiVersion: config.apiVersion,
enabledFeatures: [...config.enabledFeatures],
};
}
if (message.method === "plugin.activate") {
if (!context) throw new PluginError("failed_precondition", "Plugin must be initialized first");
if (!activated) {
const disposable = await plugin.activate(context);
if (disposable && typeof disposable.dispose === "function") context.subscriptions.add(disposable);
activated = true;
}
return null;
}
if (message.method === "plugin.deactivate") {
if (!deactivated) {
deactivated = true;
await plugin.deactivate?.();
context?.subscriptions.dispose();
}
return null;
}
throw new PluginError("unsupported", `Unsupported host method: ${message.method}`);
}
const dispose = transport.onMessage((message) => {
if (message && typeof message === "object" && Object.hasOwn(message, "frame")) {
try { cancelUnhandledStream(transport, message); }
catch { transport.close(); }
return;
}
if (client.accept(message)) return;
if (!message || message.jsonrpc !== "2.0") return;
if (message.method === "$/cancelRequest") {
cancellation.get(message.params?.cancellationId)?.cancel();
return;
}
if (!Object.hasOwn(message, "id")) return;
const cancellationId = message.cancellationId;
const source = new CancellationTokenSource();
if (cancellationId) cancellation.set(cancellationId, source);
void handleRequest(message).then(
(result) => transport.post({ jsonrpc: "2.0", id: message.id, result }),
(error) => {
const rpcError = normalizeError(error);
transport.post(makeRpcFailure(message.id, rpcError.code, rpcError.message, rpcError.data));
},
).finally(() => {
if (cancellationId) cancellation.delete(cancellationId);
source.dispose();
});
});
return {
async dispose() {
dispose();
client.close();
for (const source of cancellation.values()) source.cancel();
cancellation.clear();
if (!deactivated) {
await plugin.deactivate?.();
context?.subscriptions.dispose();
}
transport.close();
},
};
}