[Init] Initial commit - NetMesh terminal manager

electron/plugins/runtimePeer.test.cjs

@@ -0,0 +1,618 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const test = require("node:test");
+const { MessageChannel } = require("node:worker_threads");
+
+const { PluginRpcError, PluginRpcRouter, RPC_ERRORS } = require("./rpcRouter.cjs");
+
+test("runtime peer exposes secure host capabilities over the canonical RPC transport", async () => {
+  const { startPluginRuntime } = await import("./runtime/runtimePeer.mjs");
+  const { port1, port2 } = new MessageChannel();
+  const values = new Map();
+  const calls = [];
+  const deadlines = [];
+  const host = new PluginRpcRouter({
+    pluginId: "com.example.peer",
+    send(message) { port1.postMessage(message); },
+    handlers: {
+      "storage.get": async () => {
+        throw new PluginRpcError(RPC_ERRORS.invalidArgument, "Invalid storage key");
+      },
+      "storage.set": async ({ key, value }) => { values.set(key, value); return null; },
+      "secrets.set": async ({ key, value }) => {
+        calls.push(["secret", key, value]);
+        return {
+          secret: { kind: "secret", id: "secret-reference-0000000000000000", key },
+        };
+      },
+      "secrets.get": async () => ({
+        found: true,
+        secret: { kind: "secret", id: "secret-reference-0000000000000000", key: "api-key" },
+      }),
+      "credentials.createLease": async ({ operationId }) => ({
+        kind: "secret-lease",
+        id: "l".repeat(32),
+        operationId,
+        expiresAt: 10_000,
+      }),
+      "network.request": async ({ url, timeoutMs }, requestContext) => {
+        deadlines.push(["network", requestContext.deadlineMs, timeoutMs]);
+        return {
+          url,
+          status: 200,
+          headers: {},
+          body: { encoding: "base64", data: "b2s=" },
+        };
+      },
+      "filesystem.readFile": async ({ path }) => ({ data: `read:${path}` }),
+      "filesystem.writeFile": async ({ path, data }) => { calls.push(["write", path, data]); return null; },
+      "filesystem.stat": async () => ({ kind: "file", size: 2, modifiedAt: 1 }),
+      "filesystem.readDirectory": async () => ({ entries: [{ name: "file", kind: "file" }] }),
+      "companion.start": async () => ({ handleId: "companion-handle-000000000000" }),
+      "companion.request": async ({ method, params, timeoutMs }, requestContext) => {
+        deadlines.push(["companion", requestContext.deadlineMs, timeoutMs]);
+        return { method, params };
+      },
+      "companion.stop": async ({ handleId }) => { calls.push(["stop", handleId]); return null; },
+      "log.write": async () => null,
+    },
+  });
+  let resolveUnhandledStreamCancellation;
+  let rejectUnhandledStreamCancellation;
+  const unhandledStreamCancellation = new Promise((resolve, reject) => {
+    resolveUnhandledStreamCancellation = resolve;
+    rejectUnhandledStreamCancellation = reject;
+  });
+  port1.on("message", (message) => {
+    const accepted = host.accept(message);
+    if (message?.frame?.streamId === "unhandled" && message.frame.kind === "cancel") {
+      accepted.then(resolveUnhandledStreamCancellation, rejectUnhandledStreamCancellation);
+    }
+  });
+  const lifecycle = [];
+  const peer = await startPluginRuntime({
+    port: port2,
+    config: {
+      pluginId: "com.example.peer",
+      pluginVersion: "1.0.0",
+      netcattyVersion: "1.0.0",
+      apiVersion: "0.1.0-internal",
+      enabledFeatures: [],
+    },
+    async loadPlugin() {
+      return {
+        default: {
+          async activate(context) {
+            lifecycle.push("activate");
+            await assert.rejects(
+              context.storage.get("invalid"),
+              (error) => error?.code === "invalid_argument"
+                && error?.message === "Invalid storage key",
+            );
+            await context.storage.set("answer", 42);
+            const secret = await context.secrets.set("api-key", "value");
+            const lease = await context.credentials.createLease(secret, {
+              operationId: "network:login",
+              purpose: "Authenticate",
+            });
+            assert.equal(lease.operationId, "network:login");
+            const vaultLease = await context.credentials.createLease({
+              kind: "credential",
+              id: "vault-credential-1",
+            }, {
+              operationId: "connection:login",
+              purpose: "Authenticate connection",
+            });
+            assert.equal(vaultLease.operationId, "connection:login");
+            assert.equal((await context.network.request({
+              url: "https://example.com",
+              timeoutMs: 45_000,
+            })).status, 200);
+            assert.equal(await context.filesystem.readFile("/tmp/file"), "read:/tmp/file");
+            await context.filesystem.writeFile("/tmp/file", "ok", { overwrite: true });
+            assert.equal((await context.filesystem.stat("/tmp/file")).kind, "file");
+            assert.equal((await context.filesystem.readDirectory("/tmp")).length, 1);
+            const companion = await context.companions.start("com.example.peer.helper");
+            assert.deepEqual(await companion.request("echo", { value: 1 }, { timeoutMs: 50_000 }), {
+              method: "echo",
+              params: { value: 1 },
+            });
+            await companion.stop();
+          },
+          async deactivate() { lifecycle.push("deactivate"); },
+        },
+      };
+    },
+  });
+  const initialized = await host.request("plugin.initialize", {
+    netcattyVersion: "1.0.0",
+    apiVersion: "0.1.0-internal",
+    supportedFeatures: [],
+  });
+  assert.equal(initialized.pluginId, "com.example.peer");
+  const unhandledStream = await host.streams.openOutgoing("unhandled", 1024);
+  await unhandledStreamCancellation;
+  await assert.rejects(unhandledStream.write(new Uint8Array([1])), /closed/);
+  await assert.rejects(
+    host.request("plugin.unknown", {}),
+    (error) => error?.code === -32012 && error?.data?.pluginCode === "unsupported",
+  );
+  await host.request("plugin.activate", {});
+  assert.equal(values.get("answer"), 42);
+  assert.deepEqual(calls, [
+    ["secret", "api-key", "value"],
+    ["write", "/tmp/file", "ok"],
+    ["stop", "companion-handle-000000000000"],
+  ]);
+  assert.deepEqual(deadlines, [
+    ["network", 45_000, 45_000],
+    ["companion", 50_000, 50_000],
+  ]);
+  await host.request("plugin.deactivate", {});
+  await peer.dispose();
+  host.close();
+  assert.deepEqual(lifecycle, ["activate", "deactivate"]);
+});
+
+test("runtime companion handles retry a failed stop request", async () => {
+  const { startPluginRuntime } = await import("./runtime/runtimePeer.mjs");
+  const { port1, port2 } = new MessageChannel();
+  let stopCalls = 0;
+  const host = new PluginRpcRouter({
+    pluginId: "com.example.retry-stop",
+    send(message) { port1.postMessage(message); },
+    handlers: {
+      "companion.start": async () => ({ handleId: "companion-handle-000000000001" }),
+      "companion.stop": async () => {
+        stopCalls += 1;
+        if (stopCalls === 1) throw new Error("transient stop failure");
+        return null;
+      },
+    },
+  });
+  port1.on("message", (message) => host.accept(message));
+  const peer = await startPluginRuntime({
+    port: port2,
+    config: {
+      pluginId: "com.example.retry-stop",
+      pluginVersion: "1.0.0",
+      netcattyVersion: "1.0.0",
+      apiVersion: "0.1.0-internal",
+      enabledFeatures: [],
+    },
+    async loadPlugin() {
+      return {
+        default: {
+          async activate(context) {
+            const companion = await context.companions.start("com.example.retry-stop.helper");
+            await assert.rejects(companion.stop());
+            await companion.stop();
+          },
+        },
+      };
+    },
+  });
+  await host.request("plugin.initialize", {
+    netcattyVersion: "1.0.0",
+    apiVersion: "0.1.0-internal",
+    supportedFeatures: [],
+  });
+  await host.request("plugin.activate", {});
+  assert.equal(stopCalls, 2);
+  await peer.dispose();
+  host.close();
+});
+
+test("runtime peer exposes contribution APIs and routes host UI events", async () => {
+  const { startPluginRuntime } = await import("./runtime/runtimePeer.mjs");
+  const { port1, port2 } = new MessageChannel();
+  const calls = [];
+  const host = new PluginRpcRouter({
+    pluginId: "com.example.ui",
+    send(message) { port1.postMessage(message); },
+    handlers: {
+      "settings.get": async ({ settingId }) => ({ found: true, value: `value:${settingId}` }),
+      "settings.update": async ({ settingId, value }) => {
+        calls.push(["setting", settingId, value]);
+        return { restartRequired: false };
+      },
+      "commands.execute": async ({ command, args }) => {
+        calls.push(["execute", command, args]);
+        return "host-result";
+      },
+      "contextKeys.set": async ({ key, value }) => { calls.push(["context", key, value]); return null; },
+      "views.getState": async ({ viewId, scopeId }) => ({ state: { viewId, scopeId } }),
+      "views.setState": async ({ viewId, scopeId, state }) => {
+        calls.push(["view-state", viewId, scopeId, state]);
+        return null;
+      },
+      "views.postMessage": async ({ viewId, message }) => { calls.push(["view-message", viewId, message]); },
+    },
+  });
+  port1.on("message", (message) => host.accept(message));
+  const events = [];
+  let pluginContext;
+  const peer = await startPluginRuntime({
+    port: port2,
+    config: {
+      pluginId: "com.example.ui",
+      pluginVersion: "1.0.0",
+      netcattyVersion: "1.0.0",
+      apiVersion: "0.1.0-internal",
+      enabledFeatures: [],
+      environment: {
+        locale: "en-GB",
+        theme: "light",
+        reducedMotion: false,
+        highContrast: true,
+        themeTokens: { "--background": "initial" },
+      },
+    },
+    async loadPlugin() {
+      return {
+        default: {
+          async activate(context) {
+            pluginContext = context;
+            assert.equal(context.environment.locale, "fr-FR");
+            assert.equal(context.environment.theme, "dark");
+            assert.equal(context.environment.highContrast, true);
+            assert.deepEqual(context.environment.themeTokens, { "--background": "active" });
+            assert.throws(() => {
+              context.environment.themeTokens["--background"] = "mutated";
+            }, /read only/u);
+            context.settings.onDidChange((event) => events.push(["settings", event.settingId]));
+            context.environment.onDidChange((event) => events.push([
+              "environment",
+              event.locale,
+              event.theme,
+              event.themeTokens["--background"],
+            ]));
+            context.views.onDidReceiveMessage("com.example.ui.view", (message) => events.push(["view", message]));
+            context.commands.registerCommand("com.example.ui.hello", async (args, invocation) => ({ args, source: invocation.source }));
+            context.commands.registerCommand("com.example.ui.void", async () => undefined);
+            const staleDisposable = context.commands.registerCommand("com.example.ui.replaceable", async () => "old");
+            staleDisposable.dispose();
+            context.commands.registerCommand("com.example.ui.replaceable", async () => "new");
+            staleDisposable.dispose();
+            assert.equal(await context.settings.get("com.example.ui.greeting"), "value:com.example.ui.greeting");
+            assert.deepEqual(await context.settings.update("com.example.ui.greeting", "hello"), { restartRequired: false });
+            assert.equal(await context.commands.executeCommand("com.example.ui.hello", { nested: true }), "host-result");
+            await context.contextKeys.set("com.example.ui.ready", true);
+            assert.deepEqual(await context.views.getState("com.example.ui.view", "window-1"), {
+              viewId: "com.example.ui.view",
+              scopeId: "window-1",
+            });
+            await context.views.setState("com.example.ui.view", "window-1", { selected: 2 });
+            context.views.postMessage("com.example.ui.view", { ready: true });
+          },
+        },
+      };
+    },
+  });
+  await host.request("plugin.initialize", {
+    netcattyVersion: "1.0.0",
+    apiVersion: "0.1.0-internal",
+    supportedFeatures: [],
+  });
+  await host.request("plugin.activate", {
+    environment: {
+      locale: "fr-FR",
+      theme: "dark",
+      reducedMotion: true,
+      highContrast: true,
+      themeTokens: { "--background": "active" },
+    },
+  });
+  assert.deepEqual(await host.request("plugin.command.execute", {
+    command: "com.example.ui.hello",
+    args: { name: "Catty" },
+    invocation: { source: "palette" },
+  }), { args: { name: "Catty" }, source: "palette" });
+  assert.equal(await host.request("plugin.command.execute", {
+    command: "com.example.ui.void",
+    invocation: { source: "palette" },
+  }), null);
+  assert.equal(await host.request("plugin.command.execute", {
+    command: "com.example.ui.replaceable",
+    invocation: { source: "palette" },
+  }), "new");
+
+  host.notify("plugin.settings.changed", { settingId: "com.example.ui.greeting", scope: "application", scopeId: "application", source: "host" });
+  host.notify("plugin.environment.changed", {
+    locale: "zh-CN",
+    theme: "dark",
+    reducedMotion: true,
+    highContrast: false,
+    themeTokens: { "--background": "updated" },
+  });
+  host.notify("plugin.view.message", { viewId: "com.example.ui.view", message: { ping: true } });
+  await new Promise((resolve) => setImmediate(resolve));
+
+  assert.equal(pluginContext.environment.locale, "zh-CN");
+  assert.equal(pluginContext.environment.reducedMotion, true);
+  assert.deepEqual(pluginContext.environment.themeTokens, { "--background": "updated" });
+  assert.deepEqual(events, [
+    ["settings", "com.example.ui.greeting"],
+    ["environment", "zh-CN", "dark", "updated"],
+    ["view", { ping: true }],
+  ]);
+  assert.deepEqual(calls, [
+    ["setting", "com.example.ui.greeting", "hello"],
+    ["execute", "com.example.ui.hello", { nested: true }],
+    ["context", "com.example.ui.ready", true],
+    ["view-state", "com.example.ui.view", "window-1", { selected: 2 }],
+    ["view-message", "com.example.ui.view", { ready: true }],
+  ]);
+  await peer.dispose();
+  host.close();
+});
+
+test("runtime peer registers provider handlers and routes immutable terminal lifecycle events", async () => {
+  const { startPluginRuntime } = await import("./runtime/runtimePeer.mjs");
+  const { port1, port2 } = new MessageChannel();
+  const host = new PluginRpcRouter({
+    pluginId: "com.example.provider",
+    send(message) { port1.postMessage(message); },
+  });
+  port1.on("message", (message) => host.accept(message));
+  const invocations = [];
+  const terminalEvents = [];
+  let cancellationObservedResolve;
+  const cancellationObserved = new Promise((resolve) => {
+    cancellationObservedResolve = resolve;
+  });
+  const peer = await startPluginRuntime({
+    port: port2,
+    config: {
+      pluginId: "com.example.provider",
+      pluginVersion: "1.0.0",
+      netcattyVersion: "1.0.0",
+      apiVersion: "0.1.0-internal",
+      enabledFeatures: [],
+    },
+    async loadPlugin() {
+      return {
+        default: {
+          async activate(context) {
+            context.terminals.onDidChange((event) => terminalEvents.push(event));
+            const staleDisposable = context.providers.register(
+              "com.example.provider.completion",
+              "terminal.completion",
+              async () => "stale",
+            );
+            staleDisposable.dispose();
+            context.providers.register(
+              "com.example.provider.completion",
+              "terminal.completion",
+              async (invocation) => {
+                invocations.push(invocation);
+                if (invocation.operation === "wait") {
+                  await new Promise((resolve) => {
+                    invocation.cancellationToken.onCancellationRequested(() => {
+                      cancellationObservedResolve();
+                      resolve();
+                    });
+                  });
+                }
+                return { items: [{ label: "status" }] };
+              },
+            );
+            staleDisposable.dispose();
+          },
+        },
+      };
+    },
+  });
+  await host.request("plugin.initialize", {
+    netcattyVersion: "1.0.0",
+    apiVersion: "0.1.0-internal",
+    supportedFeatures: [],
+  });
+  await host.request("plugin.activate", {});
+
+  assert.deepEqual(await host.request("provider.invoke", {
+    providerId: "com.example.provider.completion",
+    kind: "terminal.completion",
+    operation: "provide",
+    requestId: "request-1",
+    payload: { input: "sta" },
+    deadlineMs: 1_000,
+  }), {
+    requestId: "request-1",
+    status: "ok",
+    result: { items: [{ label: "status" }] },
+  });
+  assert.equal(invocations.length, 1);
+  assert.equal(invocations[0].providerId, "com.example.provider.completion");
+  assert.equal(invocations[0].kind, "terminal.completion");
+  assert.equal(invocations[0].operation, "provide");
+  assert.equal(invocations[0].deadlineMs, 1_000);
+  assert.equal(invocations[0].cancellationToken.isCancellationRequested, false);
+  assert.equal(Object.isFrozen(invocations[0].payload), true);
+
+  await assert.rejects(
+    host.request("provider.invoke", {
+      providerId: "com.example.provider.completion",
+      kind: "terminal.hover",
+      operation: "provide",
+      requestId: "request-kind-mismatch",
+    }),
+    (error) => error?.code === RPC_ERRORS.failedPrecondition,
+  );
+
+  const event = {
+    type: "cwdChanged",
+    session: {
+      sessionId: "session-1",
+      protocol: "ssh",
+      status: "connected",
+      cwd: "/srv/app",
+    },
+  };
+  host.notify("plugin.terminal.event", event);
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.deepEqual(terminalEvents, [event]);
+  assert.equal(Object.isFrozen(terminalEvents[0]), true);
+  assert.equal(Object.isFrozen(terminalEvents[0].session), true);
+
+  const controller = new AbortController();
+  const cancelledRequest = host.request("provider.invoke", {
+    providerId: "com.example.provider.completion",
+    kind: "terminal.completion",
+    operation: "wait",
+    requestId: "request-cancelled",
+  }, { signal: controller.signal });
+  await new Promise((resolve) => setImmediate(resolve));
+  controller.abort();
+  await assert.rejects(cancelledRequest, (error) => error?.code === RPC_ERRORS.cancelled);
+  await cancellationObserved;
+
+  await peer.dispose();
+  host.close();
+});
+
+test("runtime peer routes connection and importer Provider operation maps", async () => {
+  const { startPluginRuntime } = await import("./runtime/runtimePeer.mjs");
+  const { port1, port2 } = new MessageChannel();
+  const host = new PluginRpcRouter({
+    pluginId: "com.example.connection",
+    send(message) { port1.postMessage(message); },
+  });
+  port1.on("message", (message) => host.accept(message));
+  const invocations = [];
+  let legacyError;
+  let legacyImporterError;
+  const peer = await startPluginRuntime({
+    port: port2,
+    config: {
+      pluginId: "com.example.connection",
+      pluginVersion: "1.0.0",
+      netcattyVersion: "1.0.0",
+      apiVersion: "0.1.0-internal",
+      enabledFeatures: [],
+    },
+    async loadPlugin() {
+      return {
+        default: {
+          async activate(context) {
+            try {
+              context.providers.register("com.example.connection.legacy", "connection", async () => null);
+            } catch (error) {
+              legacyError = { code: error?.code, message: error?.message };
+            }
+            context.providers.register("com.example.connection.transport", "connection", {
+              validateConfiguration(invocation) {
+                invocations.push([invocation.operation, invocation.payload.configuration]);
+                return { valid: true, issues: [] };
+              },
+              probe(invocation) {
+                invocations.push([invocation.operation, invocation.payload.configuration]);
+                return { available: true };
+              },
+              open() {
+                throw new Error("open is not invoked by this test");
+              },
+              resize(invocation) {
+                invocations.push([invocation.operation, invocation.payload.columns, invocation.payload.rows]);
+                return null;
+              },
+              signal(invocation) {
+                invocations.push([invocation.operation, invocation.payload.signal]);
+                return null;
+              },
+              reconnect(invocation) {
+                invocations.push([invocation.operation, invocation.payload.connectionId]);
+                return null;
+              },
+              close(invocation) {
+                invocations.push([invocation.operation, invocation.payload.connectionId]);
+                return null;
+              },
+              getStatus(invocation) {
+                invocations.push([invocation.operation, invocation.payload.connectionId]);
+                return { status: "connected" };
+              },
+            });
+            try {
+              context.providers.register("com.example.connection.legacyImporter", "importer", async () => null);
+            } catch (error) {
+              legacyImporterError = { code: error?.code, message: error?.message };
+            }
+            context.providers.register("com.example.connection.importer", "importer", {
+              detect(invocation) {
+                invocations.push([invocation.operation, invocation.payload.fileName]);
+                return { confidence: 0.75, format: "example" };
+              },
+              parse() {
+                throw new Error("parse is not invoked by this test");
+              },
+            });
+          },
+        },
+      };
+    },
+  });
+  await host.request("plugin.initialize", {
+    netcattyVersion: "1.0.0",
+    apiVersion: "0.1.0-internal",
+    supportedFeatures: [],
+  });
+  await host.request("plugin.activate", {});
+
+  assert.deepEqual(legacyError, {
+    code: "invalid_argument",
+    message: "Connection Provider handler must be an operation map",
+  });
+  assert.deepEqual(legacyImporterError, {
+    code: "invalid_argument",
+    message: "Importer Provider handler must be an operation map",
+  });
+  assert.deepEqual(await host.request("provider.invoke", {
+    providerId: "com.example.connection.transport",
+    kind: "connection",
+    operation: "resize",
+    requestId: "connection-resize-1",
+    payload: { connectionId: "connection-1", operationId: "operation-1", columns: 132, rows: 44 },
+    deadlineMs: 1_000,
+  }), {
+    requestId: "connection-resize-1",
+    status: "ok",
+    result: null,
+  });
+  assert.deepEqual(await host.request("provider.invoke", {
+    providerId: "com.example.connection.importer",
+    kind: "importer",
+    operation: "detect",
+    requestId: "importer-detect-1",
+    payload: {
+      fileName: "hosts.json",
+      sample: { encoding: "base64", data: "e30=" },
+    },
+    deadlineMs: 1_000,
+  }), {
+    requestId: "importer-detect-1",
+    status: "ok",
+    result: { confidence: 0.75, format: "example" },
+  });
+  assert.deepEqual(await host.request("provider.invoke", {
+    providerId: "com.example.connection.transport",
+    kind: "connection",
+    operation: "getStatus",
+    requestId: "connection-status-1",
+    payload: { connectionId: "connection-1", operationId: "operation-2" },
+    deadlineMs: 1_000,
+  }), {
+    requestId: "connection-status-1",
+    status: "ok",
+    result: { status: "connected" },
+  });
+  assert.deepEqual(invocations, [
+    ["resize", 132, 44],
+    ["detect", "hosts.json"],
+    ["getStatus", "connection-1"],
+  ]);
+
+  await peer.dispose();
+  host.close();
+});