@termix-ssh/plugin-sdk 1.0.12 → 1.0.15

package/dist/testing.js

@@ -100,7 +100,7 @@ function emptyHostRecord(id, userId) {
     };
 }
 function applyHostInput(record, input) {
-    const { tags, pluginSettings: _settings, forceKeyboardInteractive: _fki, ...rest } = input;
+    const { tags, pluginSettings: _settings, pluginEnable: _pluginEnable, forceKeyboardInteractive: _fki, password: _password, key: _key, keyPassword: _keyPassword, keyType: _keyType, sudoPassword: _sudoPassword, protocolAuth: _protocolAuth, ...rest } = input;
     const next = { ...record };
     for (const [key, value] of Object.entries(rest)) {
         if (value !== undefined)
@@ -124,6 +124,9 @@ export function createFakeContext(options = {}) {
     const pluginId = options.pluginId ?? "test-plugin";
     const disposals = [];
     const emitted = [];
+    const hostStatusProviders = [];
+    const activityProviders = [];
+    const hostLockProviders = [];
     const kv = new Map();
     const tables = [];
     const syncEntities = [];
@@ -136,6 +139,7 @@ export function createFakeContext(options = {}) {
     const settingsValidators = new Set();
     const sshConnections = [];
     const hostShares = [];
+    const hostShareSets = [];
     const desktopWindows = [];
     const externalClientLaunches = [];
     const credentialReads = [];
@@ -158,6 +162,7 @@ export function createFakeContext(options = {}) {
     };
     const secretStore = new Map();
     const audits = [];
+    const auditSubscribers = new Set();
     const activities = [];
     const trackedSessions = [];
     const interactions = [];
@@ -195,6 +200,7 @@ export function createFakeContext(options = {}) {
         revokedSessions: [],
         loginFailures: new Map(),
         userTokens: [],
+        policies: [],
     };
     const sshClient = options.sshClient ?? {};
     let actor = options.actor;
@@ -261,7 +267,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 +467,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) => {
@@ -502,6 +529,10 @@ export function createFakeContext(options = {}) {
                 hostShares.push({ hostId, targets, permissionLevel, durationHours });
                 return { hostId, shared: true };
             },
+            setShares: async (hostId, grants) => {
+                hostShareSets.push({ hostId, grants: [...grants] });
+                return { hostId, shared: true };
+            },
             listUsers: async () => options.shareableUsers ?? [],
             listRoles: async () => options.shareableRoles ?? [],
             trackSession: (hostId) => {
@@ -519,7 +550,37 @@ 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);
+                    };
+                },
+            },
+            locks: {
+                provide: (provider) => {
+                    hostLockProviders.push(provider);
+                    return () => {
+                        const at = hostLockProviders.indexOf(provider);
+                        if (at >= 0)
+                            hostLockProviders.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 +604,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 +645,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);
@@ -682,6 +778,23 @@ export function createFakeContext(options = {}) {
                     expiresAt: new Date(Date.now() + ttl * 1000).toISOString(),
                 };
             },
+            policy: {
+                provide: (provider) => {
+                    auth.policies.push(provider);
+                    return () => {
+                        const at = auth.policies.indexOf(provider);
+                        if (at >= 0)
+                            auth.policies.splice(at, 1);
+                    };
+                },
+            },
+            listSecondFactors: () => [
+                ...auth.secondFactors.map((factor) => ({
+                    id: factor.id,
+                    pluginId,
+                })),
+                ...(options.secondFactors ?? []),
+            ],
         },
         users: {
             getLocale: async (userId) => options.locales?.[userId] ?? null,
@@ -696,8 +809,10 @@ export function createFakeContext(options = {}) {
                 return { success: true };
             },
             available: () => options.desktopAvailable ?? false,
+            local: options.desktopLocal ?? unavailableDesktopLocal(),
         },
         credentials: {
+            list: async () => [...(options.credentialSummaries ?? [])],
             listSshKeys: async () => [
                 ...(options.sshKeyCredentials ?? []),
                 ...createdSshKeys.map((key) => ({
@@ -716,6 +831,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 +984,9 @@ export function createFakeContext(options = {}) {
             return errors;
         },
         disposals,
+        hostStatusProviders,
+        activityProviders,
+        hostLockProviders,
         emitted,
         kv,
         tables,
@@ -873,6 +997,7 @@ export function createFakeContext(options = {}) {
         coreSettings,
         sshConnections,
         hostShares,
+        hostShareSets,
         auth,
         desktopWindows,
         externalClientLaunches,
@@ -886,6 +1011,10 @@ export function createFakeContext(options = {}) {
         tls,
         secretStore,
         audits,
+        emitAudit: (entry) => {
+            for (const handler of auditSubscribers)
+                handler(entry);
+        },
         activities,
         trackedSessions,
         interactions,
@@ -930,6 +1059,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 +1110,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,
@@ -949,8 +1122,14 @@ export function createMockCtx(options = {}) {
         services: options.services,
         protocolTargets: options.protocolTargets,
         sshKeyCredentials: options.sshKeyCredentials,
+        credentialSummaries: options.credentialSummaries,
         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,
@@ -961,6 +1140,7 @@ export function createMockCtx(options = {}) {
         baseUrl: options.baseUrl,
         linkedUsers: options.linkedUsers,
         loginAttemptLimit: options.loginAttemptLimit,
+        secondFactors: options.secondFactors,
         locales: options.locales,
         manifest: {
             capabilities: options.capabilities ?? [],
@@ -1077,6 +1257,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();
@@ -1109,6 +1307,10 @@ export function createMockCtx(options = {}) {
                 require("hosts:write");
                 return ctx.hosts.share(hostId, targets, permissionLevel, durationHours);
             },
+            setShares: async (hostId, grants) => {
+                require("hosts:write");
+                return ctx.hosts.setShares(hostId, grants);
+            },
             listUsers: async () => {
                 require("hosts:write");
                 return ctx.hosts.listUsers();
@@ -1125,7 +1327,32 @@ 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);
+                },
+            },
+            locks: {
+                provide: (provider) => {
+                    require("hosts:lock");
+                    return ctx.hosts.locks.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 +1373,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");
@@ -1236,6 +1472,13 @@ export function createMockCtx(options = {}) {
                 require("users:impersonate");
                 return ctx.auth.issueUserToken(userId, tokenOptions);
             },
+            policy: {
+                provide: (provider) => {
+                    require("auth:policy");
+                    return ctx.auth.policy.provide(provider);
+                },
+            },
+            listSecondFactors: () => ctx.auth.listSecondFactors(),
         },
         users: {
             getLocale: async (userId) => {
@@ -1243,6 +1486,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,8 +1511,13 @@ export function createMockCtx(options = {}) {
                 return ctx.desktop.launchExternalClient(request);
             },
             available: () => ctx.desktop.available(),
+            local: gateDesktopLocal(ctx.desktop.local, () => require("desktop:local")),
         },
         credentials: {
+            list: async () => {
+                require("credentials:use");
+                return ctx.credentials.list();
+            },
             listSshKeys: async () => {
                 require("credentials:use");
                 return ctx.credentials.listSshKeys();
@@ -1271,6 +1534,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 +1565,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/vitest-preset.js

@@ -8,6 +8,7 @@
  *
  * Two projects: tests/backend runs in node, tests/frontend in jsdom.
  */
+import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -84,6 +85,28 @@ export function pluginVitestConfig(configUrl, options = {}) {
     // 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] } };
+    // dedupe alone is not enough: react-dom or the testing library loaded from
+    // the linked SDK's own node_modules pull in a second React, and hooks then
+    // see no renderer.
+    if (!sdkDir.startsWith(pluginDir)) {
+        const pluginRequire = createRequire(path.join(pluginDir, "package.json"));
+        for (const name of [
+            "react",
+            "react-dom",
+            "@testing-library/react",
+            "react-i18next",
+            "i18next",
+        ]) {
+            if (alias[name])
+                continue;
+            try {
+                alias[name] = path.dirname(pluginRequire.resolve(`${name}/package.json`));
+            }
+            catch {
+                // Not installed in the plugin: leave it to normal resolution.
+            }
+        }
+    }
     const resolve = {
         alias,
         dedupe: ["react", "react-dom", "react-i18next", "i18next"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@termix-ssh/plugin-sdk",
-  "version": "1.0.12",
+  "version": "1.0.15",
   "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": {

package/schema/manifest.schema.json

@@ -151,9 +151,11 @@
           "process:spawn",
           "users:write",
           "auth:provide",
+          "auth:policy",
           "system:tls",
           "device:serial",
           "hosts:write",
+          "hosts:export",
           "credentials:use",
           "credentials:write",
           "network:outbound",
@@ -163,7 +165,12 @@
           "events:core",
           "notify:send",
           "audit:read",
+          "network:probe",
+          "hosts:status-provide",
+          "hosts:activity-provide",
+          "hosts:lock",
           "desktop:window",
+          "desktop:local",
           "users:impersonate",
           "db:core-refs",
           "hosts:read",
@@ -1261,6 +1268,11 @@
       "enum": ["mirror", "local", "server"],
       "description": "How a desktop linked to a server treats this plugin: mirror follows the server, local is decided on each desktop, server never runs on a linked desktop. Defaults to mirror."
     },
+    "runtime": {
+      "type": "string",
+      "enum": ["desktop"],
+      "description": "desktop: the plugin only loads on a desktop app's own embedded backend, never on a server. It implies desktop local and may declare desktop:local."
+    },
     "nativeDependencies": {
       "type": "array",
       "minItems": 1,

package/dist/host/types/src/ui/sidebar/host-export-payload.d.ts

@@ -1,30 +0,0 @@
-export type FieldGroup = "connection" | "notes" | "tags" | "proxy" | "jumpHosts" | "featureFlags" | "advanced";
-export interface ExportPayload {
-    version?: string;
-    exportedAt?: string;
-    credentials?: Record<string, unknown>[];
-    hosts: Record<string, unknown>[];
-}
-export declare const SECRET_KEYS: string[];
-/**
- * Keys inside a plugin's JSON host settings that hold secrets, per plugin and
- * field, from each manifest's `secretKeys`.
- */
-export type PluginSecretKeys = Record<string, Record<string, string[]>>;
-/** Reads the secret keys the plugins declare in their host settings. */
-export declare function pluginSecretKeys(summaries: Array<{
-    id: string;
-    contributes?: {
-        settings?: {
-            host?: {
-                fields?: Array<{
-                    key: string;
-                    secretKeys?: string[];
-                }>;
-            };
-        };
-    } | null;
-}>): PluginSecretKeys;
-export declare function hostKey(host: Record<string, unknown>): string;
-export declare function buildExportPayload(raw: ExportPayload, selected: Set<string> | null, groups: Set<FieldGroup>, withCredentials: boolean, pluginSecrets?: PluginSecretKeys): ExportPayload;
-export declare function maskSecrets(payload: ExportPayload, pluginSecrets?: PluginSecretKeys): ExportPayload;