@termix-ssh/plugin-sdk 1.0.11 → 1.0.13

package/dist/testing.js

@@ -124,6 +124,8 @@ export function createFakeContext(options = {}) {
     const pluginId = options.pluginId ?? "test-plugin";
     const disposals = [];
     const emitted = [];
+    const hostStatusProviders = [];
+    const activityProviders = [];
     const kv = new Map();
     const tables = [];
     const syncEntities = [];
@@ -158,6 +160,7 @@ export function createFakeContext(options = {}) {
     };
     const secretStore = new Map();
     const audits = [];
+    const auditSubscribers = new Set();
     const activities = [];
     const trackedSessions = [];
     const interactions = [];
@@ -261,7 +264,7 @@ export function createFakeContext(options = {}) {
         files: {
             // A fake path; a test that needs a real folder uses the OS temp dir
             // itself, not this double.
-            dataDir: async () => `/tmp/${pluginId}`,
+            dataDir: async () => options.dataDir ?? `/tmp/${pluginId}`,
         },
         db: options.db
             ? {
@@ -461,6 +464,27 @@ export function createFakeContext(options = {}) {
         },
         disposables,
         hosts: {
+            importMany: async (rows) => {
+                const created = rows.map(() => nextHostId++);
+                return {
+                    success: created.length,
+                    updated: 0,
+                    skipped: 0,
+                    failed: 0,
+                    errors: [],
+                    createdHostIds: created,
+                };
+            },
+            importSshConfig: async () => ({
+                success: 0,
+                updated: 0,
+                skipped: 0,
+                failed: 0,
+                errors: [],
+                createdHostIds: [],
+            }),
+            exportMany: async () => ({ hosts: [] }),
+            registerImportNormalizer: () => () => { },
             list: async () => [...hostsById.values()],
             get: async (hostId) => hostsById.get(hostId) ?? null,
             checkAccess: async (hostId) => {
@@ -519,7 +543,27 @@ export function createFakeContext(options = {}) {
             recordActivity: async (hostId, type, hostName) => {
                 activities.push({ hostId, type, hostName });
             },
+            probeTargets: async (filter) => (options.probeTargets ?? []).filter((target) => !filter?.hostIds || filter.hostIds.includes(target.id)),
+            sessionActive: (hostId) => options.activeSessions?.includes(hostId) ?? false,
+            activity: {
+                provide: (provider) => {
+                    activityProviders.push(provider);
+                    return () => {
+                        const at = activityProviders.indexOf(provider);
+                        if (at >= 0)
+                            activityProviders.splice(at, 1);
+                    };
+                },
+            },
             status: {
+                provide: (provider) => {
+                    hostStatusProviders.push(provider);
+                    return () => {
+                        const at = hostStatusProviders.indexOf(provider);
+                        if (at >= 0)
+                            hostStatusProviders.splice(at, 1);
+                    };
+                },
                 get: async (hostId) => hostStatuses.get(hostId) ?? null,
                 check: async (hostId) => hostStatuses.get(hostId) ?? null,
                 reportLogin: (hostId, outcome) => {
@@ -543,11 +587,36 @@ export function createFakeContext(options = {}) {
             after: (delayMs, fn) => schedule("after", delayMs, fn),
         },
         audit: {
+            subscribe: (handler) => {
+                auditSubscribers.add(handler);
+                return () => {
+                    auditSubscribers.delete(handler);
+                };
+            },
+            list: async (listOptions) => {
+                const matching = filterAuditEntries(options.auditEntries ?? [], listOptions?.filters).reverse();
+                const offset = listOptions?.offset ?? 0;
+                return {
+                    entries: matching.slice(offset, offset + (listOptions?.limit ?? 50)),
+                    total: matching.length,
+                };
+            },
+            exportBatches: async function* (filters, batchSize) {
+                const matching = filterAuditEntries(options.auditEntries ?? [], filters);
+                const size = batchSize ?? 500;
+                for (let at = 0; at < matching.length; at += size) {
+                    yield matching.slice(at, at + size);
+                }
+            },
             record: async (entry) => {
                 audits.push({ ...entry });
             },
         },
+        network: {
+            tcpProbe: async (host, port) => options.reachable?.(host, port) ?? false,
+        },
         ssh: {
+            probe: async (hostId, probeOptions) => options.reachable?.(hostId, probeOptions?.port) ?? false,
             connect: async (host, connectOptions) => {
                 sshConnections.push({ host, options: connectOptions });
                 return {
@@ -559,6 +628,16 @@ export function createFakeContext(options = {}) {
                     dispose: () => { },
                 };
             },
+            exec: async (host) => {
+                sshConnections.push({ host });
+                return {
+                    stdout: "",
+                    stderr: "",
+                    code: 0,
+                    truncated: false,
+                    timedOut: false,
+                };
+            },
             withConnection: async (host, connectOptions, fn) => {
                 sshConnections.push({ host, pool: connectOptions.pool });
                 return fn(sshClient);
@@ -696,6 +775,7 @@ export function createFakeContext(options = {}) {
                 return { success: true };
             },
             available: () => options.desktopAvailable ?? false,
+            local: options.desktopLocal ?? unavailableDesktopLocal(),
         },
         credentials: {
             listSshKeys: async () => [
@@ -716,6 +796,12 @@ export function createFakeContext(options = {}) {
                 credentialReads.push({ hostId, protocol });
                 return options.protocolTargets?.[`${hostId}:${protocol}`] ?? null;
             },
+            publicKey: async (credentialId) => (options.sshKeyCredentials ?? []).find((k) => k.id === credentialId)
+                ?.publicKey ?? null,
+            resolveKeyRefs: async (key, passphrase) => ({
+                key,
+                passphrase: passphrase ?? undefined,
+            }),
             registerSecretResolver: (scheme, resolve) => {
                 auth.secretResolvers.set(scheme, resolve);
                 disposals.push(() => {
@@ -863,6 +949,8 @@ export function createFakeContext(options = {}) {
             return errors;
         },
         disposals,
+        hostStatusProviders,
+        activityProviders,
         emitted,
         kv,
         tables,
@@ -886,6 +974,10 @@ export function createFakeContext(options = {}) {
         tls,
         secretStore,
         audits,
+        emitAudit: (entry) => {
+            for (const handler of auditSubscribers)
+                handler(entry);
+        },
         activities,
         trackedSessions,
         interactions,
@@ -930,6 +1022,49 @@ export function createFakeContext(options = {}) {
  * (users:impersonate on issueUserToken), and users:read on ctx.users. Reading a plugin's own settings is deliberately
  * ungated. As the SDK grows a member, add its gate here in the same shape.
  */
+function filterAuditEntries(entries, filters) {
+    return entries.filter((entry) => (filters?.userId === undefined || entry.userId === filters.userId) &&
+        (filters?.action === undefined || entry.action === filters.action) &&
+        (filters?.resourceType === undefined ||
+            entry.resourceType === filters.resourceType) &&
+        (filters?.success === undefined || entry.success === filters.success) &&
+        (filters?.startDate === undefined ||
+            entry.timestamp >= filters.startDate) &&
+        (filters?.endDate === undefined || entry.timestamp <= filters.endDate));
+}
+function gateDesktopLocal(target, check) {
+    const wrap = (value) => {
+        if (typeof value === "function") {
+            return (...args) => {
+                check();
+                return value(...args);
+            };
+        }
+        if (value && typeof value === "object") {
+            return new Proxy(value, {
+                get: (obj, key) => wrap(obj[key]),
+            });
+        }
+        return value;
+    };
+    return new Proxy(target, {
+        get: (obj, key) => key === "available"
+            ? obj.available
+            : wrap(obj[key]),
+    });
+}
+function unavailableDesktopLocal() {
+    const fail = () => {
+        throw new Error("ctx.desktop.local needs the desktopLocal test option");
+    };
+    const deep = () => new Proxy(() => fail(), { get: () => deep(), apply: () => fail() });
+    return {
+        available: () => false,
+        info: fail,
+        fs: deep(),
+        pty: deep(),
+    };
+}
 export function createMockCtx(options = {}) {
     const granted = new Set(options.capabilities ?? []);
     const checked = [];
@@ -938,6 +1073,7 @@ export function createMockCtx(options = {}) {
         actor: options.actor,
         settings: options.settings,
         coreSettings: options.coreSettings,
+        dataDir: options.dataDir,
         sshClient: options.sshClient,
         db: options.db,
         router: options.router,
@@ -950,7 +1086,12 @@ export function createMockCtx(options = {}) {
         protocolTargets: options.protocolTargets,
         sshKeyCredentials: options.sshKeyCredentials,
         desktopAvailable: options.desktopAvailable,
+        desktopLocal: options.desktopLocal,
+        auditEntries: options.auditEntries,
         hostStatuses: options.hostStatuses,
+        probeTargets: options.probeTargets,
+        activeSessions: options.activeSessions,
+        reachable: options.reachable,
         notificationChannels: options.notificationChannels,
         fetch: options.fetch,
         process: options.process,
@@ -1077,6 +1218,24 @@ export function createMockCtx(options = {}) {
             },
         },
         hosts: {
+            importMany: async (rows, importOptions) => {
+                require("hosts:write");
+                if (importOptions?.credentials?.length)
+                    require("credentials:write");
+                return ctx.hosts.importMany(rows, importOptions);
+            },
+            importSshConfig: async (content, importOptions) => {
+                require("hosts:write");
+                return ctx.hosts.importSshConfig(content, importOptions);
+            },
+            exportMany: async (exportOptions) => {
+                require("hosts:export");
+                return ctx.hosts.exportMany(exportOptions);
+            },
+            registerImportNormalizer: (normalizer) => {
+                require("hosts:write");
+                return ctx.hosts.registerImportNormalizer(normalizer);
+            },
             list: async () => {
                 require("hosts:read");
                 return ctx.hosts.list();
@@ -1125,7 +1284,26 @@ export function createMockCtx(options = {}) {
                 require("hosts:read");
                 return ctx.hosts.recordActivity(hostId, type, hostName);
             },
+            probeTargets: async (filter) => {
+                require("hosts:read");
+                return ctx.hosts.probeTargets(filter);
+            },
+            sessionActive: (hostId) => {
+                require("hosts:read");
+                return ctx.hosts.sessionActive(hostId);
+            },
+            activity: {
+                provide: (provider) => {
+                    require("hosts:activity-provide");
+                    return ctx.hosts.activity.provide(provider);
+                },
+            },
             status: {
+                provide: (provider) => {
+                    require("hosts:read");
+                    require("hosts:status-provide");
+                    return ctx.hosts.status.provide(provider);
+                },
                 get: async (hostId) => {
                     require("hosts:read");
                     return ctx.hosts.status.get(hostId);
@@ -1146,11 +1324,20 @@ export function createMockCtx(options = {}) {
         },
         ssh: {
             ...ctx.ssh,
+            probe: async (hostId, probeOptions) => {
+                require("ssh:connect");
+                return ctx.ssh.probe(hostId, probeOptions);
+            },
             connect: async (host, connectOptions) => {
                 require("ssh:connect");
                 require("credentials:use");
                 return ctx.ssh.connect(host, connectOptions);
             },
+            exec: async (host, command, execOptions) => {
+                require("ssh:connect");
+                require("credentials:use");
+                return ctx.ssh.exec(host, command, execOptions);
+            },
             withConnection: async (host, connectOptions, fn) => {
                 require("ssh:connect");
                 require("credentials:use");
@@ -1243,6 +1430,21 @@ export function createMockCtx(options = {}) {
                 return ctx.users.getLocale(userId);
             },
         },
+        audit: {
+            record: (entry) => ctx.audit.record(entry),
+            subscribe: (handler) => {
+                require("audit:read");
+                return ctx.audit.subscribe(handler);
+            },
+            list: async (listOptions) => {
+                require("audit:read");
+                return ctx.audit.list(listOptions);
+            },
+            exportBatches: (filters, batchSize) => {
+                require("audit:read");
+                return ctx.audit.exportBatches(filters, batchSize);
+            },
+        },
         desktop: {
             openIsolatedWindow: async (request) => {
                 require("desktop:window");
@@ -1253,6 +1455,7 @@ export function createMockCtx(options = {}) {
                 return ctx.desktop.launchExternalClient(request);
             },
             available: () => ctx.desktop.available(),
+            local: gateDesktopLocal(ctx.desktop.local, () => require("desktop:local")),
         },
         credentials: {
             listSshKeys: async () => {
@@ -1271,6 +1474,14 @@ export function createMockCtx(options = {}) {
                 }
                 return ctx.credentials.resolveHostProtocol(hostId, protocol);
             },
+            publicKey: async (credentialId) => {
+                require("credentials:use");
+                return ctx.credentials.publicKey(credentialId);
+            },
+            resolveKeyRefs: async (key, passphrase) => {
+                require("credentials:read");
+                return ctx.credentials.resolveKeyRefs(key, passphrase);
+            },
             registerSecretResolver: (scheme, resolve) => {
                 require("auth:provide");
                 ctx.credentials.registerSecretResolver(scheme, resolve);
@@ -1294,6 +1505,12 @@ export function createMockCtx(options = {}) {
             require("network:outbound");
             return ctx.fetch(url, init);
         },
+        network: {
+            tcpProbe: async (host, port, probeOptions) => {
+                require("network:probe");
+                return ctx.network.tcpProbe(host, port, probeOptions);
+            },
+        },
         process: {
             run: async (file, args, runOptions) => {
                 require("process:spawn");

package/dist/theme-css.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Checks a theme's CSS before core serves it.
+ *
+ * A theme is colors and styles only, so its file may hold nothing but rules
+ * whose every selector starts with the theme's own class (`.nord`,
+ * `:root.nord`, `html.nord ...`), optionally inside @media or @supports.
+ * Anything that could load from elsewhere or run code is refused: @import,
+ * url() to another host, other at-rules, expression() and javascript:.
+ */
+/** Every problem with a theme's CSS, empty when it is safe to serve. */
+export declare function validateThemeCss(css: string, themeId: string): string[];

package/dist/theme-css.js

@@ -0,0 +1,142 @@
+/**
+ * Checks a theme's CSS before core serves it.
+ *
+ * A theme is colors and styles only, so its file may hold nothing but rules
+ * whose every selector starts with the theme's own class (`.nord`,
+ * `:root.nord`, `html.nord ...`), optionally inside @media or @supports.
+ * Anything that could load from elsewhere or run code is refused: @import,
+ * url() to another host, other at-rules, expression() and javascript:.
+ */
+const ALLOWED_BLOCK_AT_RULES = new Set(["media", "supports"]);
+function stripComments(css) {
+    return css.replace(/\/\*[\s\S]*?\*\//g, " ");
+}
+/** Splits on commas that are not inside parentheses or brackets. */
+function splitSelectors(prelude) {
+    const parts = [];
+    let depth = 0;
+    let current = "";
+    for (const ch of prelude) {
+        if (ch === "(" || ch === "[")
+            depth += 1;
+        if (ch === ")" || ch === "]")
+            depth -= 1;
+        if (ch === "," && depth === 0) {
+            parts.push(current);
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    parts.push(current);
+    return parts.map((part) => part.trim());
+}
+function withoutStrings(css) {
+    return css.replace(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/g, '""');
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** Index of the brace closing the one at `open`, skipping strings. */
+function matchingBrace(css, open) {
+    let depth = 0;
+    let quote = null;
+    for (let i = open; i < css.length; i += 1) {
+        const ch = css[i];
+        if (quote) {
+            if (ch === "\\")
+                i += 1;
+            else if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'")
+            quote = ch;
+        else if (ch === "{")
+            depth += 1;
+        else if (ch === "}") {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+function checkUrls(css, errors) {
+    const urls = css.matchAll(/url\(\s*(['"]?)([^'")]*)\1\s*\)/gi);
+    for (const match of urls) {
+        const target = match[2].trim();
+        if (target.startsWith("data:"))
+            continue;
+        if (/^[a-z][a-z0-9+.-]*:/i.test(target) || target.startsWith("//")) {
+            errors.push(`url(${target}) points outside the plugin`);
+        }
+    }
+}
+function checkRules(css, scope, themeId, errors) {
+    let index = 0;
+    while (index < css.length) {
+        const rest = css.slice(index);
+        if (rest.trim() === "")
+            return;
+        const open = css.indexOf("{", index);
+        const semicolon = css.indexOf(";", index);
+        if (semicolon !== -1 && (open === -1 || semicolon < open)) {
+            const statement = css.slice(index, semicolon).trim();
+            errors.push(statement.startsWith("@")
+                ? `${statement.split(/\s/)[0]} is not allowed in a theme`
+                : `Unexpected "${statement}" outside a rule`);
+            index = semicolon + 1;
+            continue;
+        }
+        if (open === -1) {
+            errors.push(`Unexpected "${rest.trim()}" at the end`);
+            return;
+        }
+        const close = matchingBrace(css, open);
+        if (close === -1) {
+            errors.push("A rule is missing its closing brace");
+            return;
+        }
+        const prelude = css.slice(index, open).trim();
+        const body = css.slice(open + 1, close);
+        if (prelude.startsWith("@")) {
+            const name = prelude.slice(1).split(/[\s(]/)[0].toLowerCase();
+            if (ALLOWED_BLOCK_AT_RULES.has(name)) {
+                checkRules(body, scope, themeId, errors);
+            }
+            else {
+                errors.push(`@${name} is not allowed in a theme`);
+            }
+        }
+        else {
+            for (const selector of splitSelectors(prelude)) {
+                if (!scope.test(selector)) {
+                    errors.push(`Selector "${selector}" must start with .${themeId}, :root.${themeId} or html.${themeId}`);
+                }
+            }
+            if (withoutStrings(body).includes("{")) {
+                errors.push(`Nested rules are not allowed in "${prelude}"`);
+            }
+        }
+        index = close + 1;
+    }
+}
+/** Every problem with a theme's CSS, empty when it is safe to serve. */
+export function validateThemeCss(css, themeId) {
+    const errors = [];
+    const clean = stripComments(css);
+    if (/@import\b/i.test(clean))
+        errors.push("@import is not allowed in a theme");
+    if (/expression\s*\(/i.test(clean))
+        errors.push("expression() is not allowed in a theme");
+    if (/javascript:/i.test(clean))
+        errors.push("javascript: is not allowed in a theme");
+    if (/-moz-binding|behavior\s*:/i.test(clean))
+        errors.push("Script bindings are not allowed in a theme");
+    checkUrls(clean, errors);
+    const id = escapeRegExp(themeId);
+    const scope = new RegExp(`^(?::root|html)?\\.${id}(?![\\w-])`);
+    checkRules(clean, scope, themeId, errors);
+    return [...new Set(errors)];
+}

package/dist/vitest-preset.d.ts

@@ -27,8 +27,14 @@ export declare function pluginVitestConfig(configUrl: string, options?: PluginVi
         enforce: "pre";
         load(id: string): string;
     }[];
+    server: {
+        fs: {
+            allow: string[];
+        };
+    };
     resolve: {
         alias: Record<string, string>;
+        dedupe: string[];
     };
     test: {
         globals: boolean;
@@ -40,8 +46,14 @@ export declare function pluginVitestConfig(configUrl: string, options?: PluginVi
                 enforce: "pre";
                 load(id: string): string;
             }[];
+            server: {
+                fs: {
+                    allow: string[];
+                };
+            };
             resolve: {
                 alias: Record<string, string>;
+                dedupe: string[];
             };
             test: {
                 name: string;
@@ -59,8 +71,14 @@ export declare function pluginVitestConfig(configUrl: string, options?: PluginVi
                 enforce: "pre";
                 load(id: string): string;
             }[];
+            server: {
+                fs: {
+                    allow: string[];
+                };
+            };
             resolve: {
                 alias: Record<string, string>;
+                dedupe: string[];
             };
             test: {
                 name: string;

package/dist/vitest-preset.js

@@ -80,9 +80,18 @@ export function pluginVitestConfig(configUrl, options = {}) {
     // unexpectedly". Threads don't.
     const pool = "threads";
     const plugins = [wasmBinaryPlugin()];
+    // A local SDK linked into node_modules sits outside the plugin folder, so
+    // Vite must be allowed to read it, and React must come from the plugin.
+    const sdkDir = fs.realpathSync(fileURLToPath(new URL("..", import.meta.url)));
+    const server = { fs: { allow: [pluginDir, sdkDir] } };
+    const resolve = {
+        alias,
+        dedupe: ["react", "react-dom", "react-i18next", "i18next"],
+    };
     return {
         plugins,
-        resolve: { alias },
+        server,
+        resolve,
         test: {
             globals: true,
             setupFiles: [setupFile],
@@ -90,7 +99,8 @@ export function pluginVitestConfig(configUrl, options = {}) {
             projects: [
                 {
                     plugins,
-                    resolve: { alias },
+                    server,
+                    resolve,
                     test: {
                         name: `${pluginId}:backend`,
                         root: pluginDir,
@@ -103,7 +113,8 @@ export function pluginVitestConfig(configUrl, options = {}) {
                 },
                 {
                     plugins,
-                    resolve: { alias },
+                    server,
+                    resolve,
                     test: {
                         name: `${pluginId}:frontend`,
                         root: pluginDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@termix-ssh/plugin-sdk",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "description": "The contract between Termix core and a plugin: types, the capability catalog and the manifest schema.",
   "license": "Apache-2.0",
   "repository": {
@@ -85,6 +85,10 @@
       "types": "./dist/ssh-certs.d.ts",
       "default": "./dist/ssh-certs.js"
     },
+    "./ssh-keys": {
+      "types": "./dist/ssh-keys.d.ts",
+      "default": "./dist/ssh-keys.js"
+    },
     "./tsconfig.plugin.json": "./tsconfig.plugin.json",
     "./schema/manifest.schema.json": "./schema/manifest.schema.json",
     "./ui": {