@termix-ssh/plugin-sdk 1.0.12 → 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/package.json

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

package/schema/manifest.schema.json

@@ -154,6 +154,7 @@
           "system:tls",
           "device:serial",
           "hosts:write",
+          "hosts:export",
           "credentials:use",
           "credentials:write",
           "network:outbound",
@@ -163,7 +164,11 @@
           "events:core",
           "notify:send",
           "audit:read",
+          "network:probe",
+          "hosts:status-provide",
+          "hosts:activity-provide",
           "desktop:window",
+          "desktop:local",
           "users:impersonate",
           "db:core-refs",
           "hosts:read",
@@ -1261,6 +1266,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;