mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 03:50:52 +00:00
* fix(plugins): address residual Codex sync secret and backup gaps Retain provider→plugin secret bindings so disconnect can wipe credentials after a plugin is disabled, keep overwritten secrets on failed reconnect, and snapshot live-empty sidecars in protective backups. Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com> * fix(plugins): restore overwritten sync secrets on rejected reconnect Stash prior plaintext and SecretRef id on overwrite, restore them when connect fails, and discard the stash after a successful reconnect so saved provider credentials keep resolving. Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com> * fix(plugins): make sync secret overwrite stash opt-in Only the syncPutSecret path stashes prior plaintext/SecretRef so ordinary secrets.set overwrites do not leave credentials in process memory. Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com> * fix(plugins): host-own sync provider bindings and clear failed stashes Move provider→plugin bindings into a dedicated DB table outside plugin-writable secrets, validate provider namespace ownership, and drop overwrite stashes when replacement writes fail. Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com> * fix(plugins): keep overwrite stash until restore write succeeds Only drop the prior plaintext after encrypt+upsert succeeds so a failed restore can still retry and recover the saved SecretRef. Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com> * fix(plugins): preserve overwrite stash across retries and prefix deletes Do not replace an existing restore stash on later puts, and clear matching stash entries when deleteByKeyPrefix wipes sync credentials on disconnect. Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com> --------- Co-authored-by: Cursor Agent <cursoragent@cursor.com> Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>
1567 lines
67 KiB
JavaScript
1567 lines
67 KiB
JavaScript
"use strict";
|
|
|
|
const fs = require("node:fs/promises");
|
|
const { randomUUID } = require("node:crypto");
|
|
|
|
const { isPluginDevelopmentEnabled } = require("./constants.cjs");
|
|
const { raceWithAbort } = require("./rpcRouter.cjs");
|
|
const {
|
|
INLINE_SYNC_OBJECT_SAFE_BYTES,
|
|
MAX_SYNC_OBJECT_BYTES,
|
|
STREAM_WINDOW_BYTES,
|
|
} = require("./extensionProviderService.cjs");
|
|
const { assertSecretKey } = require("./secretStore.cjs");
|
|
|
|
const CHANNELS = Object.freeze({
|
|
status: "netcatty:plugins:status",
|
|
list: "netcatty:plugins:list",
|
|
install: "netcatty:plugins:install",
|
|
setEnabled: "netcatty:plugins:set-enabled",
|
|
restart: "netcatty:plugins:restart",
|
|
uninstall: "netcatty:plugins:uninstall",
|
|
contributions: "netcatty:plugins:contributions",
|
|
contributionIcon: "netcatty:plugins:contribution-icon",
|
|
contributionsChanged: "netcatty:plugins:contributions-changed",
|
|
executeCommand: "netcatty:plugins:execute-command",
|
|
updateSetting: "netcatty:plugins:update-setting",
|
|
resetSetting: "netcatty:plugins:reset-setting",
|
|
setEnvironment: "netcatty:plugins:set-environment",
|
|
terminalProviders: "netcatty:plugins:terminal-providers",
|
|
terminalProvide: "netcatty:plugins:terminal-provide",
|
|
terminalCancel: "netcatty:plugins:terminal-cancel",
|
|
terminalSessionEvent: "netcatty:plugins:terminal-session-event",
|
|
extensionProviders: "netcatty:plugins:extension-providers",
|
|
extensionInvoke: "netcatty:plugins:extension-invoke",
|
|
extensionCancel: "netcatty:plugins:extension-cancel",
|
|
syncConnect: "netcatty:plugins:sync-connect",
|
|
syncDisconnect: "netcatty:plugins:sync-disconnect",
|
|
syncGetAccount: "netcatty:plugins:sync-get-account",
|
|
syncGetCapabilities: "netcatty:plugins:sync-get-capabilities",
|
|
syncReadObject: "netcatty:plugins:sync-read-object",
|
|
syncReadChunk: "netcatty:plugins:sync-read-chunk",
|
|
syncWriteObject: "netcatty:plugins:sync-write-object",
|
|
syncWriteBegin: "netcatty:plugins:sync-write-begin",
|
|
syncWriteChunk: "netcatty:plugins:sync-write-chunk",
|
|
syncWriteCommit: "netcatty:plugins:sync-write-commit",
|
|
syncDeleteObject: "netcatty:plugins:sync-delete-object",
|
|
syncPutSecret: "netcatty:plugins:sync-put-secret",
|
|
syncDeleteSecrets: "netcatty:plugins:sync-delete-secrets",
|
|
syncRestoreSecrets: "netcatty:plugins:sync-restore-secrets",
|
|
syncSidecarsCollect: "netcatty:plugins:sync-sidecars-collect",
|
|
syncSidecarsApply: "netcatty:plugins:sync-sidecars-apply",
|
|
hostAvailableSync: "netcatty:plugins:host-available-sync",
|
|
connectionStart: "netcatty:plugins:connection-start",
|
|
connectionWrite: "netcatty:plugins:connection-write",
|
|
connectionControl: "netcatty:plugins:connection-control",
|
|
connectionData: "netcatty:plugins:connection-data",
|
|
connectionClosed: "netcatty:plugins:connection-closed",
|
|
credentialCatalogUpdate: "netcatty:plugins:credential-catalog-update",
|
|
authenticationChallenge: "netcatty:plugins:authentication-challenge",
|
|
authenticationRespond: "netcatty:plugins:authentication-respond",
|
|
importerDetect: "netcatty:plugins:importer-detect",
|
|
importerSelectFile: "netcatty:plugins:importer-select-file",
|
|
importerReleaseFile: "netcatty:plugins:importer-release-file",
|
|
importerParseFile: "netcatty:plugins:importer-parse-file",
|
|
importerProgress: "netcatty:plugins:importer-progress",
|
|
openView: "netcatty:plugins:open-view",
|
|
closeView: "netcatty:plugins:close-view",
|
|
setViewBounds: "netcatty:plugins:set-view-bounds",
|
|
setViewVisibility: "netcatty:plugins:set-view-visibility",
|
|
viewMessage: "netcatty:plugins:view-message",
|
|
viewMessagePosted: "netcatty:plugins:view-message-posted",
|
|
viewClosed: "netcatty:plugins:view-closed",
|
|
getScopeCatalog: "netcatty:plugins:get-scope-catalog",
|
|
setScopeCatalog: "netcatty:plugins:set-scope-catalog",
|
|
scopeCatalogChanged: "netcatty:plugins:scope-catalog-changed",
|
|
});
|
|
|
|
const SCOPE_KINDS = Object.freeze(["workspace", "host", "session", "device"]);
|
|
const MAX_ACTIVE_TERMINAL_REQUESTS_PER_SENDER = 64;
|
|
const MAX_SYNC_TRANSFERS_PER_SENDER = 8;
|
|
const SYNC_TRANSFER_TTL_MS = 5 * 60_000;
|
|
const MAX_IMPORT_FILE_BYTES = 64 * 1024 * 1024;
|
|
const MAX_IMPORT_SELECTIONS_PER_SENDER = 8;
|
|
const IMPORT_SELECTION_TTL_MS = 5 * 60_000;
|
|
const DEFAULT_CONNECTION_STATUS_POLL_MS = 500;
|
|
|
|
function boundedErrorMessage(value, fallback = "Plugin connection failed") {
|
|
const message = typeof value === "string" && value
|
|
? value
|
|
: value && typeof value === "object" && typeof value.message === "string" && value.message
|
|
? value.message
|
|
: fallback;
|
|
return String(message).slice(0, 2048);
|
|
}
|
|
|
|
function connectionOutputCloseDetails(reason) {
|
|
if (reason === "end") return { reason: "exited", exitCode: 0 };
|
|
if (typeof reason === "string") return { reason: "closed" };
|
|
if (reason && typeof reason === "object") {
|
|
return {
|
|
reason: "error",
|
|
error: boundedErrorMessage(reason, "Plugin connection output stream failed"),
|
|
};
|
|
}
|
|
return { reason: "closed" };
|
|
}
|
|
|
|
function boundedConnectionDiagnostics(value) {
|
|
if (!Array.isArray(value)) return [];
|
|
return value.slice(0, 256).flatMap((issue) => {
|
|
if (!issue || typeof issue !== "object" || Array.isArray(issue)) return [];
|
|
const severity = issue.severity === "error" ? "error" : "warning";
|
|
const message = typeof issue.message === "string" && issue.message
|
|
? issue.message.slice(0, 2048)
|
|
: "";
|
|
if (!message) return [];
|
|
const code = typeof issue.code === "string" && issue.code
|
|
? issue.code.slice(0, 128)
|
|
: undefined;
|
|
const path = typeof issue.path === "string" && issue.path
|
|
? issue.path.slice(0, 1024)
|
|
: undefined;
|
|
return [Object.freeze({
|
|
severity,
|
|
message,
|
|
...(code ? { code } : {}),
|
|
...(path ? { path } : {}),
|
|
})];
|
|
});
|
|
}
|
|
|
|
function connectionStatusCloseDetails(status) {
|
|
const diagnostics = boundedConnectionDiagnostics(status?.diagnostics);
|
|
return {
|
|
reason: status?.status === "error" ? "error" : "closed",
|
|
...(status?.message ? { error: boundedErrorMessage(status.message) } : {}),
|
|
...(diagnostics.length > 0 ? { diagnostics } : {}),
|
|
};
|
|
}
|
|
|
|
function normalizePluginScopeCatalog(value) {
|
|
const source = value && typeof value === "object" ? value : {};
|
|
const result = {};
|
|
let total = 0;
|
|
for (const kind of SCOPE_KINDS) {
|
|
const entries = Array.isArray(source[kind]) ? source[kind] : [];
|
|
const seen = new Set();
|
|
result[kind] = [];
|
|
for (const entry of entries) {
|
|
const id = typeof entry?.id === "string" ? entry.id.trim() : "";
|
|
const label = typeof entry?.label === "string" ? entry.label.trim() : "";
|
|
if (!id || id.length > 256 || id.includes("\0") || !label || label.length > 512 || seen.has(id)) continue;
|
|
if (++total > 4096) throw new TypeError("Plugin setting scope catalog is too large");
|
|
seen.add(id);
|
|
result[kind].push(Object.freeze({ id, label }));
|
|
}
|
|
Object.freeze(result[kind]);
|
|
}
|
|
return Object.freeze(result);
|
|
}
|
|
|
|
function mergePluginScopeCatalogs(catalogs) {
|
|
const result = {};
|
|
let total = 0;
|
|
for (const kind of SCOPE_KINDS) {
|
|
const seen = new Set();
|
|
result[kind] = [];
|
|
for (const catalog of catalogs) {
|
|
for (const entry of catalog?.[kind] ?? []) {
|
|
if (seen.has(entry.id) || total >= 4096) continue;
|
|
seen.add(entry.id);
|
|
total += 1;
|
|
result[kind].push(entry);
|
|
}
|
|
}
|
|
Object.freeze(result[kind]);
|
|
}
|
|
return Object.freeze(result);
|
|
}
|
|
|
|
function createTrustedPluginBridgeSender(options = {}) {
|
|
const devServerOrigin = options.devServerUrl ? new URL(options.devServerUrl).origin : null;
|
|
return (event) => {
|
|
const senderUrl = event?.senderFrame?.url || event?.sender?.getURL?.() || "";
|
|
try {
|
|
const url = new URL(senderUrl);
|
|
if (url.protocol === "app:" && url.hostname === "netcatty") return true;
|
|
return Boolean(devServerOrigin && url.origin === devServerOrigin);
|
|
} catch {
|
|
return false;
|
|
}
|
|
};
|
|
}
|
|
|
|
function registerPluginBridge(ipcMain, options) {
|
|
const manager = options.manager;
|
|
const contributionService = options.contributionService;
|
|
const terminalProviderService = options.terminalProviderService;
|
|
const terminalDataPipelineService = options.terminalDataPipelineService;
|
|
const extensionProviderService = options.extensionProviderService;
|
|
const syncSidecarService = options.syncSidecarService;
|
|
const credentialResolver = options.credentialResolver;
|
|
const secretStore = options.secretStore;
|
|
const connectionStatusPollMs = Number.isSafeInteger(options.connectionStatusPollMs)
|
|
&& options.connectionStatusPollMs >= 0
|
|
&& options.connectionStatusPollMs <= 60_000
|
|
? options.connectionStatusPollMs
|
|
: DEFAULT_CONNECTION_STATUS_POLL_MS;
|
|
const getTerminalWorkerManager = options.getTerminalWorkerManager ?? (() => null);
|
|
const selectImporterFile = options.selectImporterFile;
|
|
const viewHost = options.viewHost;
|
|
const env = options.env ?? process.env;
|
|
const isTrustedSender = options.isTrustedSender;
|
|
const defaultScopeCatalog = normalizePluginScopeCatalog({ device: [{ id: "device", label: "This device" }] });
|
|
const scopeCatalogs = new Map();
|
|
const scopeCatalogOwners = new Map();
|
|
const observedScopeCatalogSenders = new WeakSet();
|
|
const terminalRequestsBySender = new WeakMap();
|
|
const observedTerminalRequestSenders = new WeakSet();
|
|
const extensionRequestsBySender = new WeakMap();
|
|
const observedExtensionRequestSenders = new WeakSet();
|
|
const connectionSessionsBySender = new WeakMap();
|
|
const connectionMonitorsBySender = new WeakMap();
|
|
const observedConnectionSenders = new WeakSet();
|
|
const authenticationChallengesBySender = new WeakMap();
|
|
const observedAuthenticationSenders = new WeakSet();
|
|
const importerSelectionsBySender = new WeakMap();
|
|
const observedImporterSelectionSenders = new WeakSet();
|
|
const syncTransfersBySender = new WeakMap();
|
|
const observedSyncTransferSenders = new WeakSet();
|
|
const scopeCatalogSenderKey = (event) => {
|
|
const id = event?.sender?.id;
|
|
return Number.isSafeInteger(id) && id > 0 ? id : "default";
|
|
};
|
|
const currentScopeCatalog = () => mergePluginScopeCatalogs([
|
|
...scopeCatalogs.values(),
|
|
defaultScopeCatalog,
|
|
]);
|
|
const publishScopeCatalog = (event) => {
|
|
const catalog = currentScopeCatalog();
|
|
if (typeof options.broadcast === "function") options.broadcast(CHANNELS.scopeCatalogChanged, catalog);
|
|
else event?.sender?.send?.(CHANNELS.scopeCatalogChanged, catalog);
|
|
};
|
|
const observeScopeCatalogSender = (event, key) => {
|
|
const sender = event?.sender;
|
|
if (!sender || typeof sender !== "object" || observedScopeCatalogSenders.has(sender)) return;
|
|
observedScopeCatalogSenders.add(sender);
|
|
sender.once?.("destroyed", () => {
|
|
if (scopeCatalogOwners.get(key) !== sender) return;
|
|
scopeCatalogOwners.delete(key);
|
|
if (scopeCatalogs.delete(key)) publishScopeCatalog();
|
|
});
|
|
};
|
|
const configured = isPluginDevelopmentEnabled(env)
|
|
&& Boolean(manager)
|
|
&& typeof manager.initialize === "function";
|
|
const resolveManager = async () => {
|
|
if (!configured) throw new Error("Plugin development runtime is disabled or unavailable");
|
|
try {
|
|
await manager.initialize();
|
|
} catch (cause) {
|
|
throw new Error("Plugin development runtime is disabled or unavailable", { cause });
|
|
}
|
|
return manager;
|
|
};
|
|
const handle = (channel, callback) => {
|
|
ipcMain.handle(channel, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
const activeManager = await resolveManager();
|
|
return callback(activeManager, payload, event);
|
|
});
|
|
};
|
|
// These channels are called by ordinary host/terminal lifecycles even when
|
|
// the experimental plugin runtime is disabled. Treat the disabled runtime as
|
|
// an empty provider set instead of throwing (and making Electron print a
|
|
// stack trace) on every terminal mount, Vault refresh, and scope update.
|
|
const handlePassive = (channel, fallback, callback) => {
|
|
ipcMain.handle(channel, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
let activeManager;
|
|
try {
|
|
activeManager = await resolveManager();
|
|
} catch {
|
|
return typeof fallback === "function" ? fallback(payload, event) : fallback;
|
|
}
|
|
return callback(activeManager, payload, event);
|
|
});
|
|
};
|
|
const terminalRequestMap = (sender) => {
|
|
if (!sender || typeof sender !== "object") throw new Error("Plugin terminal request sender is unavailable");
|
|
let requests = terminalRequestsBySender.get(sender);
|
|
if (!requests) {
|
|
requests = new Map();
|
|
terminalRequestsBySender.set(sender, requests);
|
|
}
|
|
if (!observedTerminalRequestSenders.has(sender)) {
|
|
observedTerminalRequestSenders.add(sender);
|
|
sender.once?.("destroyed", () => {
|
|
for (const controller of requests.values()) controller.abort();
|
|
requests.clear();
|
|
});
|
|
}
|
|
return requests;
|
|
};
|
|
const extensionRequestMap = (sender) => {
|
|
if (!sender || typeof sender !== "object") throw new Error("Plugin extension request sender is unavailable");
|
|
let requests = extensionRequestsBySender.get(sender);
|
|
if (!requests) {
|
|
requests = new Map();
|
|
extensionRequestsBySender.set(sender, requests);
|
|
}
|
|
if (!observedExtensionRequestSenders.has(sender)) {
|
|
observedExtensionRequestSenders.add(sender);
|
|
sender.once?.("destroyed", () => {
|
|
for (const controller of requests.values()) controller.abort();
|
|
requests.clear();
|
|
});
|
|
}
|
|
return requests;
|
|
};
|
|
const runExtensionRequest = async (event, payload, callback) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
const requestId = payload?.requestId;
|
|
if (typeof requestId !== "string" || requestId.length < 1 || requestId.length > 128 || requestId.includes("\0")) {
|
|
throw new TypeError("Plugin extension request ID is invalid");
|
|
}
|
|
const requests = extensionRequestMap(event.sender);
|
|
if (requests.has(requestId)) throw new Error("Plugin extension request ID is already active");
|
|
if (requests.size >= MAX_ACTIVE_TERMINAL_REQUESTS_PER_SENDER) {
|
|
throw new Error("Too many active Plugin extension requests");
|
|
}
|
|
const controller = new AbortController();
|
|
requests.set(requestId, controller);
|
|
try {
|
|
await raceWithAbort(resolveManager(), controller.signal);
|
|
return await callback(controller.signal);
|
|
} finally {
|
|
if (requests.get(requestId) === controller) requests.delete(requestId);
|
|
}
|
|
};
|
|
const connectionSessionMap = (sender) => {
|
|
if (!sender || typeof sender !== "object") throw new Error("Plugin connection sender is unavailable");
|
|
let sessions = connectionSessionsBySender.get(sender);
|
|
if (!sessions) {
|
|
sessions = new Map();
|
|
connectionSessionsBySender.set(sender, sessions);
|
|
}
|
|
if (!observedConnectionSenders.has(sender)) {
|
|
observedConnectionSenders.add(sender);
|
|
sender.once?.("destroyed", () => {
|
|
const monitors = connectionMonitorsBySender.get(sender);
|
|
for (const monitor of monitors?.values?.() ?? []) monitor.controller.abort();
|
|
monitors?.clear?.();
|
|
const ownedSessions = [...sessions];
|
|
sessions.clear();
|
|
for (const [sessionId, sessionOwner] of ownedSessions) {
|
|
void (async () => {
|
|
try {
|
|
await extensionProviderService?.control?.(sessionId, "close", {}, { sessionOwner });
|
|
} catch {
|
|
extensionProviderService?.closeSessionLocal?.(sessionId, undefined, sessionOwner);
|
|
}
|
|
try {
|
|
await getTerminalWorkerManager()?.finishExternalSession?.(sessionId, { reason: "closed" }, sessionOwner);
|
|
} catch {}
|
|
})();
|
|
}
|
|
});
|
|
}
|
|
return sessions;
|
|
};
|
|
const connectionMonitorMap = (sender) => {
|
|
if (!sender || typeof sender !== "object") throw new Error("Plugin connection sender is unavailable");
|
|
let monitors = connectionMonitorsBySender.get(sender);
|
|
if (!monitors) {
|
|
monitors = new Map();
|
|
connectionMonitorsBySender.set(sender, monitors);
|
|
}
|
|
return monitors;
|
|
};
|
|
const authenticationChallengeMap = (sender) => {
|
|
if (!sender || typeof sender !== "object") throw new Error("Plugin authentication sender is unavailable");
|
|
let challenges = authenticationChallengesBySender.get(sender);
|
|
if (!challenges) {
|
|
challenges = new Map();
|
|
authenticationChallengesBySender.set(sender, challenges);
|
|
}
|
|
if (!observedAuthenticationSenders.has(sender)) {
|
|
observedAuthenticationSenders.add(sender);
|
|
sender.once?.("destroyed", () => {
|
|
for (const pending of challenges.values()) pending.reject(new Error("Plugin authentication window closed"));
|
|
challenges.clear();
|
|
});
|
|
}
|
|
return challenges;
|
|
};
|
|
const requestAuthenticationChallenge = (event, requestId, challenge, signal) => {
|
|
const challenges = authenticationChallengeMap(event.sender);
|
|
const challengeRequestId = randomUUID();
|
|
return new Promise((resolve, reject) => {
|
|
const sendCancellation = () => {
|
|
try {
|
|
event.sender.send(CHANNELS.authenticationChallenge, {
|
|
requestId,
|
|
challengeRequestId,
|
|
challengeId: challenge.id,
|
|
cancelled: true,
|
|
});
|
|
} catch {}
|
|
};
|
|
const onAbort = () => {
|
|
if (!challenges.delete(challengeRequestId)) return;
|
|
signal?.removeEventListener?.("abort", onAbort);
|
|
sendCancellation();
|
|
reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
|
|
};
|
|
const finish = (callback, value) => {
|
|
signal?.removeEventListener?.("abort", onAbort);
|
|
callback(value);
|
|
};
|
|
challenges.set(challengeRequestId, {
|
|
requestId,
|
|
challengeId: challenge.id,
|
|
resolve: (value) => finish(resolve, value),
|
|
reject: (error) => finish(reject, error),
|
|
});
|
|
if (signal?.aborted) {
|
|
onAbort();
|
|
return;
|
|
}
|
|
signal?.addEventListener?.("abort", onAbort, { once: true });
|
|
try {
|
|
event.sender.send(CHANNELS.authenticationChallenge, {
|
|
requestId,
|
|
challengeRequestId,
|
|
challenge,
|
|
});
|
|
} catch (error) {
|
|
challenges.delete(challengeRequestId);
|
|
finish(reject, error);
|
|
}
|
|
});
|
|
};
|
|
const closeImporterSelection = (selection) => {
|
|
if (!selection?.handle) return;
|
|
void selection.handle.close().catch(() => {});
|
|
};
|
|
const waitForConnectionStatusPoll = (signal) => new Promise((resolve, reject) => {
|
|
if (signal.aborted) {
|
|
reject(signal.reason ?? new DOMException("Plugin connection monitoring was cancelled", "AbortError"));
|
|
return;
|
|
}
|
|
let timer;
|
|
const onAbort = () => {
|
|
clearTimeout(timer);
|
|
reject(signal.reason ?? new DOMException("Plugin connection monitoring was cancelled", "AbortError"));
|
|
};
|
|
timer = setTimeout(() => {
|
|
signal.removeEventListener("abort", onAbort);
|
|
resolve();
|
|
}, connectionStatusPollMs);
|
|
// A zero-delay poll is used by deterministic tests and should retain the
|
|
// event loop until its immediate callback runs. Longer production polls
|
|
// remain unrefed so monitoring cannot keep the Electron process alive.
|
|
if (connectionStatusPollMs > 0) timer.unref?.();
|
|
signal.addEventListener("abort", onAbort, { once: true });
|
|
});
|
|
const pluginConnectionReadyMeta = Object.freeze({ pluginPipelineIngressBytes: 0, pluginConnectionReady: true });
|
|
const monitorPluginConnection = async ({
|
|
sessionId,
|
|
sessionOwner,
|
|
sessions,
|
|
monitors,
|
|
controller,
|
|
terminalWorkerManager,
|
|
readyPublished = false,
|
|
}) => {
|
|
if (typeof extensionProviderService?.control !== "function") return;
|
|
let hasPublishedReady = readyPublished;
|
|
let reconnectAttempted = false;
|
|
try {
|
|
while (!controller.signal.aborted && sessions.get(sessionId) === sessionOwner) {
|
|
await waitForConnectionStatusPoll(controller.signal);
|
|
if (controller.signal.aborted || sessions.get(sessionId) !== sessionOwner) return;
|
|
const status = await extensionProviderService.control(
|
|
sessionId,
|
|
"getStatus",
|
|
{},
|
|
{ signal: controller.signal, sessionOwner },
|
|
);
|
|
if (status.status === "connected") {
|
|
reconnectAttempted = false;
|
|
// A zero-byte terminal delivery transitions silent protocols out of
|
|
// the connecting UI without inventing visible terminal output.
|
|
if (!hasPublishedReady) {
|
|
await terminalWorkerManager.pushExternalOutput(sessionId, "", pluginConnectionReadyMeta, sessionOwner);
|
|
hasPublishedReady = true;
|
|
}
|
|
continue;
|
|
}
|
|
if (status.status === "closed" || status.status === "error") {
|
|
if (status.retryable === true && !reconnectAttempted) {
|
|
reconnectAttempted = true;
|
|
await extensionProviderService.control(
|
|
sessionId,
|
|
"reconnect",
|
|
{},
|
|
{ signal: controller.signal, sessionOwner },
|
|
);
|
|
continue;
|
|
}
|
|
if (sessions.get(sessionId) === sessionOwner) sessions.delete(sessionId);
|
|
try {
|
|
await terminalWorkerManager.finishExternalSession(
|
|
sessionId,
|
|
connectionStatusCloseDetails(status),
|
|
sessionOwner,
|
|
);
|
|
} finally {
|
|
extensionProviderService.closeSessionLocal(sessionId, undefined, sessionOwner);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
} catch (error) {
|
|
if (controller.signal.aborted) return;
|
|
if (sessions.get(sessionId) === sessionOwner) sessions.delete(sessionId);
|
|
try {
|
|
await terminalWorkerManager.finishExternalSession(sessionId, {
|
|
reason: "error",
|
|
error: boundedErrorMessage(error),
|
|
}, sessionOwner);
|
|
} finally {
|
|
extensionProviderService.closeSessionLocal(sessionId, undefined, sessionOwner);
|
|
}
|
|
} finally {
|
|
if (monitors.get(sessionId)?.sessionOwner === sessionOwner) monitors.delete(sessionId);
|
|
}
|
|
};
|
|
const importerSelectionMap = (sender) => {
|
|
if (!sender || typeof sender !== "object") throw new Error("Plugin importer sender is unavailable");
|
|
let selections = importerSelectionsBySender.get(sender);
|
|
if (!selections) {
|
|
selections = new Map();
|
|
importerSelectionsBySender.set(sender, selections);
|
|
}
|
|
if (!observedImporterSelectionSenders.has(sender)) {
|
|
observedImporterSelectionSenders.add(sender);
|
|
sender.once?.("destroyed", () => {
|
|
for (const selection of selections.values()) closeImporterSelection(selection);
|
|
selections.clear();
|
|
});
|
|
}
|
|
const now = Date.now();
|
|
for (const [token, selection] of selections) {
|
|
if (selection.expiresAt <= now) {
|
|
selections.delete(token);
|
|
closeImporterSelection(selection);
|
|
}
|
|
}
|
|
return selections;
|
|
};
|
|
const syncTransferMap = (sender) => {
|
|
if (!sender || typeof sender !== "object") throw new Error("Plugin sync transfer sender is unavailable");
|
|
let transfers = syncTransfersBySender.get(sender);
|
|
if (!transfers) {
|
|
transfers = new Map();
|
|
syncTransfersBySender.set(sender, transfers);
|
|
}
|
|
if (!observedSyncTransferSenders.has(sender)) {
|
|
observedSyncTransferSenders.add(sender);
|
|
sender.once?.("destroyed", () => {
|
|
for (const [transferId, transfer] of [...transfers.entries()]) {
|
|
try {
|
|
transfer.controller?.abort();
|
|
if (transfer.requestId) {
|
|
extensionRequestMap(sender).delete(transfer.requestId);
|
|
}
|
|
} catch { /* ignore */ }
|
|
transfers.delete(transferId);
|
|
}
|
|
});
|
|
}
|
|
const now = Date.now();
|
|
for (const [transferId, transfer] of [...transfers.entries()]) {
|
|
if (typeof transfer.expiresAt === "number" && transfer.expiresAt <= now) {
|
|
try {
|
|
transfer.controller?.abort();
|
|
if (transfer.requestId) extensionRequestMap(sender).delete(transfer.requestId);
|
|
} catch { /* ignore */ }
|
|
transfers.delete(transferId);
|
|
}
|
|
}
|
|
return transfers;
|
|
};
|
|
const releaseSyncTransfer = (sender, transferId, transfer) => {
|
|
const transfers = syncTransfersBySender.get(sender);
|
|
if (transfers && transferId && transfers.get(transferId) === transfer) {
|
|
transfers.delete(transferId);
|
|
}
|
|
if (transfer?.requestId) {
|
|
const requests = extensionRequestMap(sender);
|
|
if (requests.get(transfer.requestId) === transfer.controller || transfer.controller == null) {
|
|
requests.delete(transfer.requestId);
|
|
}
|
|
}
|
|
};
|
|
const assertSyncTransferBudget = (transfers) => {
|
|
if (transfers.size >= MAX_SYNC_TRANSFERS_PER_SENDER) {
|
|
throw new Error("Too many active Plugin sync transfers");
|
|
}
|
|
};
|
|
const coerceIpcBytes = (value, label) => {
|
|
if (value instanceof Uint8Array) return value;
|
|
if (Buffer.isBuffer(value)) return value;
|
|
if (ArrayBuffer.isView(value)) {
|
|
return Buffer.from(value.buffer, value.byteOffset, value.byteLength);
|
|
}
|
|
if (value && typeof value === "object" && value.type === "Buffer" && Array.isArray(value.data)) {
|
|
return Buffer.from(value.data);
|
|
}
|
|
throw new TypeError(`${label} must be binary bytes`);
|
|
};
|
|
const registerStreamingWriteRequest = (event, requestId) => {
|
|
if (typeof requestId !== "string" || requestId.length < 1 || requestId.length > 128 || requestId.includes("\0")) {
|
|
throw new TypeError("Plugin extension request ID is invalid");
|
|
}
|
|
const requests = extensionRequestMap(event.sender);
|
|
if (requests.has(requestId)) throw new Error("Plugin extension request ID is already active");
|
|
if (requests.size >= MAX_ACTIVE_TERMINAL_REQUESTS_PER_SENDER) {
|
|
throw new Error("Too many active Plugin extension requests");
|
|
}
|
|
const controller = new AbortController();
|
|
requests.set(requestId, controller);
|
|
return controller;
|
|
};
|
|
ipcMain.handle(CHANNELS.status, async (event) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
let available = false;
|
|
try {
|
|
await resolveManager();
|
|
available = true;
|
|
} catch {}
|
|
return { available, experimental: true };
|
|
});
|
|
handle(CHANNELS.list, async (activeManager) => activeManager.list());
|
|
handle(CHANNELS.install, async (activeManager, payload) => activeManager.install(
|
|
payload?.archivePath,
|
|
{ enable: payload?.enable === true },
|
|
));
|
|
handle(CHANNELS.setEnabled, async (activeManager, payload) => activeManager.setEnabled(
|
|
payload?.pluginId,
|
|
payload?.enabled === true,
|
|
));
|
|
handle(CHANNELS.restart, async (activeManager, payload) => activeManager.restart(payload?.pluginId));
|
|
handle(CHANNELS.uninstall, async (activeManager, payload) => activeManager.uninstall(payload?.pluginId));
|
|
handle(CHANNELS.contributions, async (_activeManager, payload) => {
|
|
if (!contributionService) throw new Error("Plugin contributions are unavailable");
|
|
return contributionService.snapshot(payload ?? {});
|
|
});
|
|
handle(CHANNELS.contributionIcon, async (_activeManager, payload) => {
|
|
if (!options.resolveContributionIcon) throw new Error("Plugin contribution icons are unavailable");
|
|
return options.resolveContributionIcon(payload);
|
|
});
|
|
handle(CHANNELS.executeCommand, async (_activeManager, payload) => {
|
|
if (!contributionService) throw new Error("Plugin contributions are unavailable");
|
|
return contributionService.executeCommand(payload?.command, payload?.args, {
|
|
source: "renderer",
|
|
context: payload?.context,
|
|
});
|
|
});
|
|
handle(CHANNELS.updateSetting, async (_activeManager, payload) => {
|
|
if (!contributionService) throw new Error("Plugin contributions are unavailable");
|
|
return contributionService.updateSetting(
|
|
payload?.pluginId,
|
|
payload?.settingId,
|
|
payload?.value,
|
|
payload?.scopeId,
|
|
{ source: "host" },
|
|
);
|
|
});
|
|
handle(CHANNELS.resetSetting, async (_activeManager, payload) => {
|
|
if (!contributionService) throw new Error("Plugin contributions are unavailable");
|
|
return contributionService.resetSetting(payload?.pluginId, payload?.settingId, payload?.scopeId);
|
|
});
|
|
handle(CHANNELS.setEnvironment, async (_activeManager, payload) => {
|
|
if (!contributionService) throw new Error("Plugin contributions are unavailable");
|
|
await contributionService.setEnvironment(payload ?? {});
|
|
viewHost?.setEnvironment?.(payload ?? {});
|
|
return null;
|
|
});
|
|
handlePassive(CHANNELS.terminalProviders, [], async (_activeManager, payload) => {
|
|
if (!terminalProviderService) throw new Error("Plugin Terminal Providers are unavailable");
|
|
return terminalProviderService.listProviders(payload ?? {});
|
|
});
|
|
ipcMain.handle(CHANNELS.terminalProvide, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
if (!terminalProviderService) throw new Error("Plugin Terminal Providers are unavailable");
|
|
const requestId = payload?.requestId;
|
|
if (typeof requestId !== "string" || requestId.length < 1 || requestId.length > 128 || requestId.includes("\0")) {
|
|
throw new TypeError("Plugin terminal request ID is invalid");
|
|
}
|
|
const requests = terminalRequestMap(event.sender);
|
|
if (requests.has(requestId)) throw new Error("Plugin terminal request ID is already active");
|
|
if (requests.size >= MAX_ACTIVE_TERMINAL_REQUESTS_PER_SENDER) {
|
|
throw new Error("Too many active Plugin terminal requests");
|
|
}
|
|
const controller = new AbortController();
|
|
requests.set(requestId, controller);
|
|
try {
|
|
await raceWithAbort(resolveManager(), controller.signal);
|
|
const { requestId: _requestId, ...providerRequest } = payload;
|
|
return await terminalProviderService.provide(providerRequest, { signal: controller.signal });
|
|
} finally {
|
|
if (requests.get(requestId) === controller) requests.delete(requestId);
|
|
}
|
|
});
|
|
ipcMain.handle(CHANNELS.terminalCancel, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
const requestId = payload?.requestId;
|
|
if (typeof requestId !== "string" || requestId.length < 1 || requestId.length > 128) {
|
|
throw new TypeError("Plugin terminal request ID is invalid");
|
|
}
|
|
const requests = terminalRequestMap(event.sender);
|
|
const controller = requests.get(requestId);
|
|
controller?.abort();
|
|
return controller != null;
|
|
});
|
|
handlePassive(CHANNELS.terminalSessionEvent, [], async (_activeManager, payload, event) => {
|
|
if (!terminalProviderService) throw new Error("Plugin Terminal Providers are unavailable");
|
|
if (terminalDataPipelineService?.acceptsSessionEvent
|
|
&& !terminalDataPipelineService.acceptsSessionEvent(payload, event?.sender?.id)) {
|
|
return [];
|
|
}
|
|
const [providers] = await Promise.all([
|
|
terminalProviderService.publishSessionEvent(payload),
|
|
terminalDataPipelineService?.handleSessionEvent?.(payload, {
|
|
webContentsId: event?.sender?.id,
|
|
}) ?? [],
|
|
]);
|
|
return providers;
|
|
});
|
|
handlePassive(CHANNELS.extensionProviders, [], async (_activeManager, payload) => {
|
|
if (!extensionProviderService) throw new Error("Plugin extension Providers are unavailable");
|
|
return extensionProviderService.listProviders(payload ?? {});
|
|
});
|
|
|
|
// Synchronous readiness probe for renderer restore paths (no await).
|
|
ipcMain.on(CHANNELS.hostAvailableSync, (event) => {
|
|
event.returnValue = Boolean(syncSidecarService);
|
|
});
|
|
|
|
// Fallback null = host gated off / manager unavailable. Renderer must treat
|
|
// null as "unavailable" (last-known) rather than an authoritative empty set.
|
|
handlePassive(CHANNELS.syncSidecarsCollect, null, async () => {
|
|
if (!syncSidecarService) return null;
|
|
return syncSidecarService.collectForSync();
|
|
});
|
|
|
|
handlePassive(CHANNELS.syncSidecarsApply, null, async (_activeManager, payload) => {
|
|
if (!syncSidecarService) return { applied: false };
|
|
const entries = await syncSidecarService.applyFromSync(payload ?? { version: 1, entries: [] });
|
|
// Include merged entries so the renderer can refresh last-known without a
|
|
// follow-up collect (preserves missing-plugin rows remote omitted).
|
|
return { applied: true, count: entries.length, entries };
|
|
});
|
|
|
|
const runSyncProvider = (channel, methodName) => {
|
|
ipcMain.handle(channel, async (event, payload) => runExtensionRequest(event, payload, async (signal) => {
|
|
if (!extensionProviderService) throw new Error("Plugin sync Providers are unavailable");
|
|
const method = extensionProviderService[methodName];
|
|
if (typeof method !== "function") throw new Error(`Plugin sync method missing: ${methodName}`);
|
|
return method.call(extensionProviderService, payload ?? {}, { signal });
|
|
}));
|
|
};
|
|
|
|
runSyncProvider(CHANNELS.syncConnect, "connectSync");
|
|
runSyncProvider(CHANNELS.syncDisconnect, "disconnectSync");
|
|
runSyncProvider(CHANNELS.syncGetAccount, "getSyncAccount");
|
|
runSyncProvider(CHANNELS.syncGetCapabilities, "getSyncCapabilities");
|
|
runSyncProvider(CHANNELS.syncDeleteObject, "deleteSyncObject");
|
|
|
|
ipcMain.handle(CHANNELS.syncReadObject, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
if (!extensionProviderService) throw new Error("Plugin sync Providers are unavailable");
|
|
const requestId = payload?.requestId;
|
|
const controller = registerStreamingWriteRequest(event, requestId);
|
|
try {
|
|
await raceWithAbort(resolveManager(), controller.signal);
|
|
const result = await extensionProviderService.readSyncObject(payload ?? {}, {
|
|
signal: controller.signal,
|
|
});
|
|
if (!result?.found || !result.bytes) {
|
|
extensionRequestMap(event.sender).delete(requestId);
|
|
return { found: false, key: payload?.key, data: null };
|
|
}
|
|
const bytes = result.bytes instanceof Uint8Array
|
|
? result.bytes
|
|
: new Uint8Array(result.bytes);
|
|
const preferStream = payload?.preferStream === true;
|
|
if (!preferStream && bytes.byteLength <= INLINE_SYNC_OBJECT_SAFE_BYTES) {
|
|
extensionRequestMap(event.sender).delete(requestId);
|
|
return {
|
|
found: true,
|
|
key: result.key,
|
|
data: bytes,
|
|
revision: result.revision,
|
|
contentType: result.contentType,
|
|
};
|
|
}
|
|
const transfers = syncTransferMap(event.sender);
|
|
assertSyncTransferBudget(transfers);
|
|
const transferId = randomUUID();
|
|
const transfer = {
|
|
kind: "read",
|
|
sender: event.sender,
|
|
requestId,
|
|
controller,
|
|
bytes,
|
|
offset: 0,
|
|
expiresAt: Date.now() + SYNC_TRANSFER_TTL_MS,
|
|
};
|
|
transfers.set(transferId, transfer);
|
|
const onAbort = () => releaseSyncTransfer(event.sender, transferId, transfer);
|
|
controller.signal.addEventListener("abort", onAbort, { once: true });
|
|
transfer.onAbort = onAbort;
|
|
return {
|
|
found: true,
|
|
key: result.key,
|
|
streamed: true,
|
|
transferId,
|
|
byteLength: bytes.byteLength,
|
|
revision: result.revision,
|
|
contentType: result.contentType,
|
|
};
|
|
} catch (error) {
|
|
extensionRequestMap(event.sender).delete(requestId);
|
|
throw error;
|
|
}
|
|
});
|
|
|
|
ipcMain.handle(CHANNELS.syncReadChunk, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
const transferId = payload?.transferId;
|
|
if (typeof transferId !== "string" || transferId.length < 1) {
|
|
throw new TypeError("Sync read transfer ID is invalid");
|
|
}
|
|
const transfers = syncTransferMap(event.sender);
|
|
const transfer = transfers.get(transferId);
|
|
if (!transfer || transfer.kind !== "read") {
|
|
throw new Error("Sync read transfer is not owned by this window");
|
|
}
|
|
if (payload?.requestId !== transfer.requestId) {
|
|
throw new Error("Sync read transfer request ID mismatch");
|
|
}
|
|
if (transfer.controller?.signal?.aborted) {
|
|
releaseSyncTransfer(event.sender, transferId, transfer);
|
|
throw new DOMException("Aborted", "AbortError");
|
|
}
|
|
transfer.expiresAt = Date.now() + SYNC_TRANSFER_TTL_MS;
|
|
const maxBytes = Number.isSafeInteger(payload?.maxBytes) && payload.maxBytes > 0
|
|
? Math.min(payload.maxBytes, STREAM_WINDOW_BYTES)
|
|
: STREAM_WINDOW_BYTES;
|
|
const start = transfer.offset;
|
|
const end = Math.min(transfer.bytes.byteLength, start + maxBytes);
|
|
const chunk = transfer.bytes.subarray(start, end);
|
|
transfer.offset = end;
|
|
const done = end >= transfer.bytes.byteLength;
|
|
if (done) releaseSyncTransfer(event.sender, transferId, transfer);
|
|
return { chunk, done };
|
|
});
|
|
|
|
ipcMain.handle(CHANNELS.syncWriteObject, async (event, payload) => runExtensionRequest(event, payload, async (signal) => {
|
|
if (!extensionProviderService) throw new Error("Plugin sync Providers are unavailable");
|
|
const data = coerceIpcBytes(payload?.data ?? payload?.bytes, "Sync writeObject data");
|
|
if (data.byteLength > INLINE_SYNC_OBJECT_SAFE_BYTES) {
|
|
throw new Error("Sync writeObject payload requires the streamed write path");
|
|
}
|
|
if (data.byteLength > MAX_SYNC_OBJECT_BYTES) {
|
|
throw new Error("Sync writeObject payload exceeds the size limit");
|
|
}
|
|
return extensionProviderService.writeSyncObject({
|
|
...payload,
|
|
bytes: data instanceof Uint8Array ? data : new Uint8Array(data),
|
|
preferStream: false,
|
|
}, { signal });
|
|
}));
|
|
|
|
ipcMain.handle(CHANNELS.syncWriteBegin, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
if (!extensionProviderService) throw new Error("Plugin sync Providers are unavailable");
|
|
const requestId = payload?.requestId;
|
|
const controller = registerStreamingWriteRequest(event, requestId);
|
|
const failBegin = (error) => {
|
|
controller.abort();
|
|
extensionRequestMap(event.sender).delete(requestId);
|
|
throw error;
|
|
};
|
|
const byteLength = payload?.byteLength;
|
|
if (!Number.isSafeInteger(byteLength) || byteLength < 1 || byteLength > MAX_SYNC_OBJECT_BYTES) {
|
|
failBegin(new TypeError("Sync writeObject byteLength is invalid"));
|
|
}
|
|
const providerId = payload?.providerId;
|
|
const key = payload?.key;
|
|
if (typeof providerId !== "string" || providerId.length < 1) {
|
|
failBegin(new TypeError("Sync writeObject provider ID is invalid"));
|
|
}
|
|
if (typeof key !== "string" || key.length < 1) {
|
|
failBegin(new TypeError("Sync writeObject key is invalid"));
|
|
}
|
|
const transfers = syncTransferMap(event.sender);
|
|
try {
|
|
assertSyncTransferBudget(transfers);
|
|
} catch (error) {
|
|
failBegin(error);
|
|
}
|
|
const transferId = randomUUID();
|
|
const transfer = {
|
|
kind: "write",
|
|
sender: event.sender,
|
|
requestId,
|
|
controller,
|
|
providerId,
|
|
key,
|
|
expectedRevision: payload?.expectedRevision,
|
|
deadlineMs: payload?.deadlineMs,
|
|
byteLength,
|
|
received: 0,
|
|
sequence: -1,
|
|
chunks: [],
|
|
signal: controller.signal,
|
|
expiresAt: Date.now() + SYNC_TRANSFER_TTL_MS,
|
|
};
|
|
transfers.set(transferId, transfer);
|
|
const onAbort = () => releaseSyncTransfer(event.sender, transferId, transfer);
|
|
controller.signal.addEventListener("abort", onAbort, { once: true });
|
|
transfer.onAbort = onAbort;
|
|
return { transferId, windowBytes: STREAM_WINDOW_BYTES };
|
|
});
|
|
|
|
ipcMain.handle(CHANNELS.syncWriteChunk, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
const transferId = payload?.transferId;
|
|
if (typeof transferId !== "string" || transferId.length < 1) {
|
|
throw new TypeError("Sync write transfer ID is invalid");
|
|
}
|
|
const transfers = syncTransferMap(event.sender);
|
|
const transfer = transfers.get(transferId);
|
|
if (!transfer || transfer.kind !== "write") {
|
|
throw new Error("Sync write transfer is not owned by this window");
|
|
}
|
|
const failChunk = (error) => {
|
|
try { transfer.controller?.abort(); } catch { /* ignore */ }
|
|
releaseSyncTransfer(event.sender, transferId, transfer);
|
|
throw error;
|
|
};
|
|
if (payload?.requestId !== transfer.requestId) {
|
|
failChunk(new Error("Sync write transfer request ID mismatch"));
|
|
}
|
|
if (transfer.signal.aborted) {
|
|
failChunk(new DOMException("Aborted", "AbortError"));
|
|
}
|
|
const sequence = payload?.sequence;
|
|
if (!Number.isSafeInteger(sequence) || sequence !== transfer.sequence + 1) {
|
|
failChunk(new TypeError("Sync write chunk sequence is invalid"));
|
|
}
|
|
let chunk;
|
|
try {
|
|
chunk = coerceIpcBytes(payload?.chunk, "Sync write chunk");
|
|
} catch (error) {
|
|
failChunk(error);
|
|
}
|
|
if (chunk.byteLength < 1 || chunk.byteLength > STREAM_WINDOW_BYTES) {
|
|
failChunk(new TypeError("Sync write chunk size is invalid"));
|
|
}
|
|
if (transfer.received + chunk.byteLength > transfer.byteLength) {
|
|
failChunk(new Error("Sync write exceeded declared byteLength"));
|
|
}
|
|
transfer.chunks.push(Buffer.from(chunk));
|
|
transfer.received += chunk.byteLength;
|
|
transfer.sequence = sequence;
|
|
transfer.expiresAt = Date.now() + SYNC_TRANSFER_TTL_MS;
|
|
return { accepted: chunk.byteLength };
|
|
});
|
|
|
|
ipcMain.handle(CHANNELS.syncWriteCommit, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
if (!extensionProviderService) throw new Error("Plugin sync Providers are unavailable");
|
|
const transferId = payload?.transferId;
|
|
if (typeof transferId !== "string" || transferId.length < 1) {
|
|
throw new TypeError("Sync write transfer ID is invalid");
|
|
}
|
|
const transfers = syncTransferMap(event.sender);
|
|
const transfer = transfers.get(transferId);
|
|
if (!transfer || transfer.kind !== "write") {
|
|
throw new Error("Sync write transfer is not owned by this window");
|
|
}
|
|
const failCommit = (error) => {
|
|
try { transfer.controller?.abort(); } catch { /* ignore */ }
|
|
releaseSyncTransfer(event.sender, transferId, transfer);
|
|
throw error;
|
|
};
|
|
if (payload?.requestId !== transfer.requestId) {
|
|
failCommit(new Error("Sync write transfer request ID mismatch"));
|
|
}
|
|
if (transfer.received !== transfer.byteLength) {
|
|
failCommit(new Error("Sync write commit size does not match byteLength"));
|
|
}
|
|
const bytes = Buffer.concat(transfer.chunks);
|
|
transfers.delete(transferId);
|
|
try {
|
|
if (transfer.signal.aborted) {
|
|
throw new DOMException("Aborted", "AbortError");
|
|
}
|
|
await raceWithAbort(resolveManager(), transfer.signal);
|
|
return await extensionProviderService.writeSyncObject({
|
|
providerId: transfer.providerId,
|
|
key: transfer.key,
|
|
bytes: new Uint8Array(bytes),
|
|
expectedRevision: transfer.expectedRevision,
|
|
preferStream: true,
|
|
deadlineMs: transfer.deadlineMs,
|
|
}, { signal: transfer.signal });
|
|
} catch (error) {
|
|
throw error;
|
|
} finally {
|
|
if (extensionRequestMap(event.sender).get(transfer.requestId) === transfer.controller
|
|
|| extensionRequestMap(event.sender).has(transfer.requestId)) {
|
|
extensionRequestMap(event.sender).delete(transfer.requestId);
|
|
}
|
|
}
|
|
});
|
|
|
|
ipcMain.handle(CHANNELS.syncPutSecret, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
if (!secretStore || typeof secretStore.set !== "function") {
|
|
throw new Error("Plugin sync secret storage is unavailable");
|
|
}
|
|
if (!extensionProviderService) throw new Error("Plugin sync Providers are unavailable");
|
|
const providerId = payload?.providerId;
|
|
if (typeof providerId !== "string" || providerId.length < 1) {
|
|
throw new TypeError("Sync provider ID is invalid");
|
|
}
|
|
const key = assertSecretKey(typeof payload?.key === "string" && payload.key
|
|
? payload.key
|
|
: "sync-credential");
|
|
const value = payload?.value;
|
|
if (typeof value !== "string" || value.length < 1) {
|
|
throw new TypeError("Sync secret value is invalid");
|
|
}
|
|
const providers = extensionProviderService.listProviders({ kind: "sync" });
|
|
const match = Array.isArray(providers)
|
|
? providers.find((entry) => entry?.provider?.id === providerId || entry?.id === providerId)
|
|
: null;
|
|
if (!match || typeof match.pluginId !== "string") {
|
|
throw new Error(`Plugin sync provider is unavailable: ${providerId}`);
|
|
}
|
|
const existing = typeof secretStore.getReference === "function"
|
|
? secretStore.getReference(match.pluginId, key)
|
|
: null;
|
|
const stored = typeof secretStore.set === "function"
|
|
? secretStore.set(match.pluginId, key, value, { stashPrevious: true })
|
|
: null;
|
|
if (!stored) {
|
|
throw new Error("Plugin sync secret storage is unavailable");
|
|
}
|
|
// Remember which plugin owns this provider so disconnect can clean secrets
|
|
// after the contribution is gone (disabled/uninstalled).
|
|
if (typeof secretStore.bindSyncProviderPlugin === "function") {
|
|
try {
|
|
secretStore.bindSyncProviderPlugin(match.pluginId, providerId);
|
|
} catch {
|
|
/* binding is best-effort; credential write already succeeded */
|
|
}
|
|
}
|
|
return Object.freeze({ ...stored, created: !existing });
|
|
});
|
|
|
|
ipcMain.handle(CHANNELS.syncDeleteSecrets, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
if (!secretStore || typeof secretStore.delete !== "function") {
|
|
throw new Error("Plugin sync secret storage is unavailable");
|
|
}
|
|
if (!extensionProviderService) throw new Error("Plugin sync Providers are unavailable");
|
|
const providerId = payload?.providerId;
|
|
if (typeof providerId !== "string" || providerId.length < 1) {
|
|
throw new TypeError("Sync provider ID is invalid");
|
|
}
|
|
const providers = extensionProviderService.listProviders({ kind: "sync" });
|
|
const match = Array.isArray(providers)
|
|
? providers.find((entry) => entry?.provider?.id === providerId || entry?.id === providerId)
|
|
: null;
|
|
let pluginId = match && typeof match.pluginId === "string" ? match.pluginId : null;
|
|
if (!pluginId && typeof secretStore.resolveSyncProviderPlugin === "function") {
|
|
pluginId = secretStore.resolveSyncProviderPlugin(providerId) ?? null;
|
|
}
|
|
if (!pluginId) {
|
|
// No live contribution and no retained binding — nothing to delete.
|
|
return { deleted: 0 };
|
|
}
|
|
const keys = Array.isArray(payload?.keys) && payload.keys.length > 0
|
|
? payload.keys
|
|
: null;
|
|
if (!keys) {
|
|
// Wipe every sync-credential* key (well-known + schema writeOnly fields).
|
|
let deleted = 0;
|
|
if (typeof secretStore.deleteByKeyPrefix === "function") {
|
|
deleted = Number(secretStore.deleteByKeyPrefix(pluginId, "sync-credential")) || 0;
|
|
}
|
|
if (typeof secretStore.unbindSyncProviderPlugin === "function") {
|
|
secretStore.unbindSyncProviderPlugin(pluginId, providerId);
|
|
}
|
|
return { deleted };
|
|
}
|
|
let deleted = 0;
|
|
for (const rawKey of keys ?? [
|
|
"sync-credential",
|
|
"sync-credential:token",
|
|
"sync-credential:secret",
|
|
"sync-credential:apiKey",
|
|
"sync-credential:accessToken",
|
|
]) {
|
|
if (typeof rawKey !== "string" || rawKey.length < 1) continue;
|
|
const key = assertSecretKey(rawKey);
|
|
try {
|
|
secretStore.delete(pluginId, key);
|
|
deleted += 1;
|
|
} catch {
|
|
/* ignore missing / unavailable keys */
|
|
}
|
|
}
|
|
return { deleted };
|
|
});
|
|
|
|
ipcMain.handle(CHANNELS.syncRestoreSecrets, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
if (!secretStore) {
|
|
throw new Error("Plugin sync secret restore is unavailable");
|
|
}
|
|
if (!extensionProviderService) throw new Error("Plugin sync Providers are unavailable");
|
|
const providerId = payload?.providerId;
|
|
if (typeof providerId !== "string" || providerId.length < 1) {
|
|
throw new TypeError("Sync provider ID is invalid");
|
|
}
|
|
const keys = Array.isArray(payload?.keys) ? payload.keys : [];
|
|
if (keys.length < 1) return { restored: 0, discarded: 0 };
|
|
const providers = extensionProviderService.listProviders({ kind: "sync" });
|
|
const match = Array.isArray(providers)
|
|
? providers.find((entry) => entry?.provider?.id === providerId || entry?.id === providerId)
|
|
: null;
|
|
let pluginId = match && typeof match.pluginId === "string" ? match.pluginId : null;
|
|
if (!pluginId && typeof secretStore.resolveSyncProviderPlugin === "function") {
|
|
pluginId = secretStore.resolveSyncProviderPlugin(providerId) ?? null;
|
|
}
|
|
if (!pluginId) return { restored: 0, discarded: 0 };
|
|
const discard = payload?.discard === true;
|
|
let restored = 0;
|
|
let discarded = 0;
|
|
for (const rawKey of keys) {
|
|
if (typeof rawKey !== "string" || rawKey.length < 1) continue;
|
|
const key = assertSecretKey(rawKey);
|
|
try {
|
|
if (discard) {
|
|
if (typeof secretStore.clearOverwriteStash === "function") {
|
|
secretStore.clearOverwriteStash(pluginId, key);
|
|
discarded += 1;
|
|
}
|
|
} else if (typeof secretStore.restoreOverwrite === "function"
|
|
&& secretStore.restoreOverwrite(pluginId, key)) {
|
|
restored += 1;
|
|
}
|
|
} catch {
|
|
/* best-effort restore/discard */
|
|
}
|
|
}
|
|
return { restored, discarded };
|
|
});
|
|
|
|
handlePassive(CHANNELS.credentialCatalogUpdate, 0, async (_activeManager, payload) => {
|
|
if (!credentialResolver || typeof credentialResolver.update !== "function") {
|
|
throw new Error("Plugin Vault credential catalog is unavailable");
|
|
}
|
|
return credentialResolver.update(payload?.entries);
|
|
});
|
|
ipcMain.handle(CHANNELS.extensionInvoke, async (event, payload) => runExtensionRequest(event, payload, async (signal) => {
|
|
if (!extensionProviderService) throw new Error("Plugin extension Providers are unavailable");
|
|
if ((payload?.kind === "connection"
|
|
&& payload?.operation !== "validateConfiguration"
|
|
&& payload?.operation !== "probe")
|
|
|| payload?.kind === "authentication"
|
|
|| (payload?.kind === "importer" && payload?.operation === "parse")) {
|
|
throw new TypeError("Stateful Provider operations require their dedicated host workflow");
|
|
}
|
|
return extensionProviderService.invoke(payload ?? {}, { signal });
|
|
}));
|
|
ipcMain.handle(CHANNELS.extensionCancel, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
const requestId = payload?.requestId;
|
|
if (typeof requestId !== "string" || requestId.length < 1 || requestId.length > 128) {
|
|
throw new TypeError("Plugin extension request ID is invalid");
|
|
}
|
|
const controller = extensionRequestMap(event.sender).get(requestId);
|
|
controller?.abort();
|
|
return controller != null;
|
|
});
|
|
ipcMain.handle(CHANNELS.connectionStart, async (event, payload) => runExtensionRequest(event, payload, async (signal) => {
|
|
if (!extensionProviderService) throw new Error("Plugin connection Providers are unavailable");
|
|
const terminalWorkerManager = getTerminalWorkerManager();
|
|
if (!terminalWorkerManager?.startExternalSession) {
|
|
throw new Error("Host terminal pipeline is unavailable for plugin connections");
|
|
}
|
|
const sessions = connectionSessionMap(event.sender);
|
|
const monitors = connectionMonitorMap(event.sender);
|
|
const sessionId = payload?.sessionId;
|
|
const sessionOwner = Symbol(`plugin-connection:${sessionId}`);
|
|
const outputDecoder = new TextDecoder("utf-8");
|
|
let credential = payload?.credential;
|
|
let closedDuringStart = false;
|
|
let providerOpened = false;
|
|
let providerCloseStarted = false;
|
|
let acceptProviderOutput = true;
|
|
const connectionController = new AbortController();
|
|
const abortConnection = () => connectionController.abort(
|
|
signal.reason ?? new DOMException("Plugin connection request was cancelled", "AbortError"),
|
|
);
|
|
if (signal.aborted) abortConnection();
|
|
else signal.addEventListener("abort", abortConnection, { once: true });
|
|
try {
|
|
if (connectionController.signal.aborted) throw connectionController.signal.reason;
|
|
await terminalWorkerManager.startExternalSession({
|
|
sessionId,
|
|
ownerToken: sessionOwner,
|
|
webContentsId: event.sender.id,
|
|
columns: payload?.columns,
|
|
rows: payload?.rows,
|
|
protocol: payload?.protocol,
|
|
hostLabel: payload?.hostLabel,
|
|
hostname: payload?.hostname,
|
|
sessionLog: payload?.sessionLog,
|
|
onInput: (data) => (providerOpened
|
|
? extensionProviderService.write(sessionId, data, sessionOwner)
|
|
: undefined),
|
|
onResize: ({ columns, rows }) => extensionProviderService.control(
|
|
sessionId,
|
|
"resize",
|
|
{ columns, rows },
|
|
{ sessionOwner },
|
|
),
|
|
onClose: async () => {
|
|
acceptProviderOutput = false;
|
|
if (sessions.get(sessionId) === sessionOwner) sessions.delete(sessionId);
|
|
if (monitors.get(sessionId)?.sessionOwner === sessionOwner) monitors.delete(sessionId);
|
|
connectionController.abort(new DOMException("Terminal session closed", "AbortError"));
|
|
providerCloseStarted = true;
|
|
if (providerOpened) {
|
|
try { await extensionProviderService.control(sessionId, "close", {}, { sessionOwner }); }
|
|
catch { extensionProviderService.closeSessionLocal(sessionId, undefined, sessionOwner); }
|
|
} else {
|
|
extensionProviderService.closeSessionLocal(sessionId, undefined, sessionOwner);
|
|
}
|
|
},
|
|
});
|
|
if (payload?.authenticationProviderId) {
|
|
const authentication = await extensionProviderService.authenticate({
|
|
providerId: payload.authenticationProviderId,
|
|
connectionProviderId: payload?.providerId,
|
|
configuration: payload?.configuration,
|
|
...(credential === undefined ? {} : { credential }),
|
|
}, (challenge) => requestAuthenticationChallenge(
|
|
event,
|
|
payload.requestId,
|
|
challenge,
|
|
connectionController.signal,
|
|
), { signal: connectionController.signal });
|
|
if (authentication.status !== "authenticated") {
|
|
throw new Error(authentication.message || "Plugin authentication did not complete");
|
|
}
|
|
credential = authentication.credential;
|
|
}
|
|
const opened = await extensionProviderService.openConnection({
|
|
...payload,
|
|
...(credential === undefined ? {} : { credential }),
|
|
}, {
|
|
signal: connectionController.signal,
|
|
sessionOwner,
|
|
onData: async (bytes) => {
|
|
if (!acceptProviderOutput || (providerOpened && sessions.get(sessionId) !== sessionOwner)) return;
|
|
const data = outputDecoder.decode(bytes, { stream: true });
|
|
if (!data) return;
|
|
try {
|
|
await terminalWorkerManager.pushExternalOutput(sessionId, data, undefined, sessionOwner);
|
|
} catch (error) {
|
|
if (!acceptProviderOutput
|
|
|| connectionController.signal.aborted
|
|
|| (providerOpened && sessions.get(sessionId) !== sessionOwner)) return;
|
|
throw error;
|
|
}
|
|
},
|
|
onOutputClose: async (reason) => {
|
|
const shouldFlushOutput = acceptProviderOutput
|
|
&& !connectionController.signal.aborted
|
|
&& (!providerOpened || sessions.get(sessionId) === sessionOwner);
|
|
acceptProviderOutput = false;
|
|
closedDuringStart = true;
|
|
if (sessions.get(sessionId) === sessionOwner) sessions.delete(sessionId);
|
|
if (monitors.get(sessionId)?.sessionOwner === sessionOwner) monitors.delete(sessionId);
|
|
connectionController.abort(new DOMException("Plugin connection output closed", "AbortError"));
|
|
const finalData = outputDecoder.decode();
|
|
let finalOutputError;
|
|
if (shouldFlushOutput && finalData) {
|
|
try { await terminalWorkerManager.pushExternalOutput(sessionId, finalData, undefined, sessionOwner); }
|
|
catch (error) { finalOutputError = error; }
|
|
}
|
|
await terminalWorkerManager.finishExternalSession(
|
|
sessionId,
|
|
finalOutputError
|
|
? { reason: "error", error: boundedErrorMessage(finalOutputError, "Plugin connection final output failed") }
|
|
: connectionOutputCloseDetails(reason),
|
|
sessionOwner,
|
|
);
|
|
},
|
|
});
|
|
providerOpened = true;
|
|
if (!closedDuringStart) {
|
|
sessions.set(opened.sessionId, sessionOwner);
|
|
monitors.set(opened.sessionId, { sessionOwner, controller: connectionController });
|
|
if (opened.status === "connected") {
|
|
// The terminal renderer treats the first delivery as the connection
|
|
// readiness boundary. Preserve that boundary for silent protocols
|
|
// whose Provider completes open before producing terminal bytes.
|
|
await terminalWorkerManager.pushExternalOutput(
|
|
opened.sessionId,
|
|
"",
|
|
pluginConnectionReadyMeta,
|
|
sessionOwner,
|
|
);
|
|
}
|
|
void monitorPluginConnection({
|
|
sessionId: opened.sessionId,
|
|
sessionOwner,
|
|
sessions,
|
|
monitors,
|
|
controller: connectionController,
|
|
terminalWorkerManager,
|
|
readyPublished: opened.status === "connected",
|
|
});
|
|
}
|
|
return opened;
|
|
} catch (error) {
|
|
acceptProviderOutput = false;
|
|
if (sessions.get(sessionId) === sessionOwner) sessions.delete(sessionId);
|
|
if (monitors.get(sessionId)?.sessionOwner === sessionOwner) monitors.delete(sessionId);
|
|
connectionController.abort(error);
|
|
if (!providerCloseStarted && providerOpened) {
|
|
try { await extensionProviderService.control(sessionId, "close", {}, { sessionOwner }); }
|
|
catch { extensionProviderService.closeSessionLocal(sessionId, undefined, sessionOwner); }
|
|
} else if (!providerCloseStarted && !closedDuringStart) {
|
|
extensionProviderService.closeSessionLocal(sessionId, undefined, sessionOwner);
|
|
}
|
|
await terminalWorkerManager.finishExternalSession(sessionId, {
|
|
reason: "error",
|
|
error: boundedErrorMessage(error),
|
|
}, sessionOwner);
|
|
throw error;
|
|
} finally {
|
|
signal.removeEventListener("abort", abortConnection);
|
|
}
|
|
}));
|
|
ipcMain.handle(CHANNELS.authenticationRespond, async (event, payload) => {
|
|
if (!isTrustedSender(event)) throw new Error("Untrusted plugin management sender");
|
|
const challengeRequestId = payload?.challengeRequestId;
|
|
if (typeof challengeRequestId !== "string" || challengeRequestId.length < 1 || challengeRequestId.length > 128) {
|
|
throw new TypeError("Plugin authentication challenge request ID is invalid");
|
|
}
|
|
const challenges = authenticationChallengeMap(event.sender);
|
|
const pending = challenges.get(challengeRequestId);
|
|
if (!pending
|
|
|| pending.requestId !== payload?.requestId
|
|
|| pending.challengeId !== payload?.challengeId) {
|
|
throw new Error("Plugin authentication challenge is not owned by this window");
|
|
}
|
|
challenges.delete(challengeRequestId);
|
|
if (payload?.cancelled === true) pending.reject(new DOMException("Cancelled", "AbortError"));
|
|
else pending.resolve(payload?.response);
|
|
return null;
|
|
});
|
|
handle(CHANNELS.connectionWrite, async (_activeManager, payload, event) => {
|
|
if (!extensionProviderService) throw new Error("Plugin connection Providers are unavailable");
|
|
const sessions = connectionSessionMap(event.sender);
|
|
const sessionOwner = sessions.get(payload?.sessionId);
|
|
if (sessionOwner === undefined) throw new Error("Plugin connection session is not owned by this window");
|
|
await extensionProviderService.write(payload.sessionId, payload.data, sessionOwner);
|
|
return null;
|
|
});
|
|
handle(CHANNELS.connectionControl, async (_activeManager, payload, event) => {
|
|
if (!extensionProviderService) throw new Error("Plugin connection Providers are unavailable");
|
|
const sessions = connectionSessionMap(event.sender);
|
|
const monitors = connectionMonitorMap(event.sender);
|
|
const terminalWorkerManager = getTerminalWorkerManager();
|
|
const sessionOwner = sessions.get(payload?.sessionId);
|
|
if (sessionOwner === undefined) throw new Error("Plugin connection session is not owned by this window");
|
|
const isClose = payload.operation === "close";
|
|
if (isClose) {
|
|
if (sessions.get(payload.sessionId) === sessionOwner) sessions.delete(payload.sessionId);
|
|
const monitor = monitors.get(payload.sessionId);
|
|
if (monitor?.sessionOwner === sessionOwner) {
|
|
monitors.delete(payload.sessionId);
|
|
monitor.controller.abort(new DOMException("Plugin connection closed", "AbortError"));
|
|
}
|
|
}
|
|
const controlResult = Promise.resolve(extensionProviderService.control(
|
|
payload.sessionId,
|
|
payload.operation,
|
|
payload.payload ?? {},
|
|
{ sessionOwner },
|
|
));
|
|
if (!isClose) return controlResult;
|
|
const settledControl = controlResult.then(
|
|
(value) => ({ status: "fulfilled", value }),
|
|
(reason) => ({ status: "rejected", reason }),
|
|
);
|
|
try {
|
|
await terminalWorkerManager?.finishExternalSession?.(
|
|
payload.sessionId,
|
|
{ reason: "closed" },
|
|
sessionOwner,
|
|
);
|
|
} catch {}
|
|
const outcome = await settledControl;
|
|
if (outcome.status === "rejected") throw outcome.reason;
|
|
return outcome.value;
|
|
});
|
|
ipcMain.handle(CHANNELS.importerDetect, async (event, payload) => runExtensionRequest(event, payload, async (signal) => {
|
|
if (!extensionProviderService) throw new Error("Plugin importer Providers are unavailable");
|
|
return extensionProviderService.detectImporter({ ...payload, sample: payload?.sample }, { signal });
|
|
}));
|
|
handle(CHANNELS.importerSelectFile, async (_activeManager, _payload, event) => {
|
|
if (typeof selectImporterFile !== "function") throw new Error("Plugin importer file selection is unavailable");
|
|
const filePath = await selectImporterFile(event);
|
|
if (!filePath) return null;
|
|
const handle = await fs.open(filePath, "r");
|
|
let retained = false;
|
|
try {
|
|
const stat = await handle.stat();
|
|
if (!stat.isFile() || stat.size < 1 || stat.size > MAX_IMPORT_FILE_BYTES) {
|
|
throw new TypeError("Plugin importer file is not a supported regular file");
|
|
}
|
|
const sample = Buffer.allocUnsafe(Math.min(stat.size, 128 * 1024));
|
|
const { bytesRead } = await handle.read(sample, 0, sample.byteLength, 0);
|
|
if (bytesRead !== sample.byteLength) throw new Error("Plugin importer file changed while sampling");
|
|
const selections = importerSelectionMap(event.sender);
|
|
if (selections.size >= MAX_IMPORT_SELECTIONS_PER_SENDER) {
|
|
throw new Error("Too many pending Plugin importer file selections");
|
|
}
|
|
const selectionToken = randomUUID();
|
|
selections.set(selectionToken, {
|
|
handle,
|
|
filePath,
|
|
fileName: filePath.split(/[\\/]/u).at(-1) || "import",
|
|
size: stat.size,
|
|
dev: stat.dev,
|
|
ino: stat.ino,
|
|
mtimeMs: stat.mtimeMs,
|
|
expiresAt: Date.now() + IMPORT_SELECTION_TTL_MS,
|
|
});
|
|
retained = true;
|
|
return { selectionToken, fileName: selections.get(selectionToken).fileName, sample: sample.subarray(0, bytesRead) };
|
|
} finally {
|
|
if (!retained) await handle.close();
|
|
}
|
|
});
|
|
handle(CHANNELS.importerReleaseFile, async (_activeManager, payload, event) => {
|
|
const selectionToken = payload?.selectionToken;
|
|
if (typeof selectionToken !== "string" || selectionToken.length < 1 || selectionToken.length > 128) {
|
|
throw new TypeError("Plugin importer selection token is invalid");
|
|
}
|
|
const selections = importerSelectionMap(event.sender);
|
|
const selection = selections.get(selectionToken);
|
|
const deleted = selections.delete(selectionToken);
|
|
closeImporterSelection(selection);
|
|
return deleted;
|
|
});
|
|
ipcMain.handle(CHANNELS.importerParseFile, async (event, payload) => runExtensionRequest(event, payload, async (signal) => {
|
|
if (!extensionProviderService) throw new Error("Plugin importer Providers are unavailable");
|
|
const selectionToken = payload?.selectionToken;
|
|
if (typeof selectionToken !== "string" || selectionToken.length < 1 || selectionToken.length > 128) {
|
|
throw new TypeError("Plugin importer selection token is invalid");
|
|
}
|
|
const selections = importerSelectionMap(event.sender);
|
|
const selection = selections.get(selectionToken);
|
|
selections.delete(selectionToken);
|
|
if (!selection || selection.expiresAt <= Date.now()) throw new Error("Plugin importer file selection expired");
|
|
const handle = selection.handle;
|
|
try {
|
|
const stat = await handle.stat();
|
|
if (!stat.isFile() || stat.size !== selection.size || stat.dev !== selection.dev
|
|
|| stat.ino !== selection.ino || stat.mtimeMs !== selection.mtimeMs) {
|
|
throw new Error("Plugin importer file changed after selection");
|
|
}
|
|
return await extensionProviderService.parseImporter({
|
|
...payload,
|
|
fileName: selection.fileName,
|
|
source: handle.createReadStream({ autoClose: false, signal, start: 0 }),
|
|
sourceByteLength: stat.size,
|
|
}, {
|
|
signal,
|
|
onProgress: (progress) => {
|
|
if (!event.sender.isDestroyed?.()) {
|
|
event.sender.send(CHANNELS.importerProgress, {
|
|
requestId: payload.requestId,
|
|
providerId: payload.providerId,
|
|
progress,
|
|
});
|
|
}
|
|
},
|
|
});
|
|
} finally {
|
|
await handle.close();
|
|
}
|
|
}));
|
|
handle(CHANNELS.openView, async (_activeManager, payload, event) => {
|
|
if (!viewHost) throw new Error("Plugin views are unavailable");
|
|
return viewHost.open(payload, event.sender);
|
|
});
|
|
handle(CHANNELS.closeView, async (_activeManager, payload, event) => {
|
|
if (!viewHost) throw new Error("Plugin views are unavailable");
|
|
await viewHost.close(payload?.instanceId, event.sender);
|
|
return null;
|
|
});
|
|
handle(CHANNELS.setViewBounds, async (_activeManager, payload, event) => {
|
|
if (!viewHost) throw new Error("Plugin views are unavailable");
|
|
viewHost.setBounds(payload?.instanceId, payload?.bounds, event.sender);
|
|
return null;
|
|
});
|
|
handle(CHANNELS.setViewVisibility, async (_activeManager, payload, event) => {
|
|
if (!viewHost) throw new Error("Plugin views are unavailable");
|
|
viewHost.setVisible(payload?.instanceId, payload?.visible, event.sender);
|
|
return null;
|
|
});
|
|
handle(CHANNELS.viewMessage, async (_activeManager, payload, event) => {
|
|
if (!viewHost) throw new Error("Plugin views are unavailable");
|
|
await viewHost.postMessage(payload?.instanceId, payload?.message, event.sender);
|
|
return null;
|
|
});
|
|
handlePassive(CHANNELS.getScopeCatalog, () => currentScopeCatalog(), async () => currentScopeCatalog());
|
|
handlePassive(CHANNELS.setScopeCatalog, null, async (_activeManager, payload, event) => {
|
|
const key = scopeCatalogSenderKey(event);
|
|
const scopeCatalog = normalizePluginScopeCatalog(payload);
|
|
scopeCatalogs.set(key, scopeCatalog);
|
|
scopeCatalogOwners.set(key, event?.sender);
|
|
observeScopeCatalogSender(event, key);
|
|
publishScopeCatalog(event);
|
|
return null;
|
|
});
|
|
contributionService?.onDidChange?.((event) => options.broadcast?.(CHANNELS.contributionsChanged, event));
|
|
contributionService?.onDidPostViewMessage?.((event) => options.broadcast?.(CHANNELS.viewMessagePosted, event));
|
|
viewHost?.onDidClose?.((event) => options.broadcast?.(CHANNELS.viewClosed, event));
|
|
}
|
|
|
|
module.exports = {
|
|
CHANNELS,
|
|
createTrustedPluginBridgeSender,
|
|
mergePluginScopeCatalogs,
|
|
normalizePluginScopeCatalog,
|
|
registerPluginBridge,
|
|
};
|