@sonde/shared 0.0.0

package/dist/schemas/packs.d.ts

@@ -0,0 +1,367 @@
+import { z } from 'zod';
+/** Parameter definition for a probe */
+export declare const ProbeParamDef: z.ZodObject<{
+    type: z.ZodEnum<["string", "number", "boolean"]>;
+    description: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: "string" | "number" | "boolean";
+    description: string;
+    required: boolean;
+    default?: unknown;
+}, {
+    type: "string" | "number" | "boolean";
+    description: string;
+    required?: boolean | undefined;
+    default?: unknown;
+}>;
+export type ProbeParamDef = z.infer<typeof ProbeParamDef>;
+/** Database role access requirement */
+export declare const DbRoleRequirement: z.ZodObject<{
+    type: z.ZodEnum<["postgres", "mysql", "mongodb"]>;
+    access: z.ZodEnum<["read-only", "read-write"]>;
+}, "strip", z.ZodTypeAny, {
+    type: "postgres" | "mysql" | "mongodb";
+    access: "read-only" | "read-write";
+}, {
+    type: "postgres" | "mysql" | "mongodb";
+    access: "read-only" | "read-write";
+}>;
+export type DbRoleRequirement = z.infer<typeof DbRoleRequirement>;
+/** System access requirements for a pack */
+export declare const PackRequirements: z.ZodObject<{
+    /** OS groups needed */
+    groups: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** File paths needed (glob OK) */
+    files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Binaries that must exist in PATH */
+    commands: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Database access if needed */
+    dbRole: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<["postgres", "mysql", "mongodb"]>;
+        access: z.ZodEnum<["read-only", "read-write"]>;
+    }, "strip", z.ZodTypeAny, {
+        type: "postgres" | "mysql" | "mongodb";
+        access: "read-only" | "read-write";
+    }, {
+        type: "postgres" | "mysql" | "mongodb";
+        access: "read-only" | "read-write";
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    groups: string[];
+    files: string[];
+    commands: string[];
+    dbRole?: {
+        type: "postgres" | "mysql" | "mongodb";
+        access: "read-only" | "read-write";
+    } | undefined;
+}, {
+    groups?: string[] | undefined;
+    files?: string[] | undefined;
+    commands?: string[] | undefined;
+    dbRole?: {
+        type: "postgres" | "mysql" | "mongodb";
+        access: "read-only" | "read-write";
+    } | undefined;
+}>;
+export type PackRequirements = z.infer<typeof PackRequirements>;
+/** Probe definition within a pack */
+export declare const ProbeDefinition: z.ZodObject<{
+    /** Probe name, e.g. "containers.list" */
+    name: z.ZodString;
+    /** Human-readable description */
+    description: z.ZodString;
+    /** Capability level required to execute */
+    capability: z.ZodEnum<["observe", "interact", "manage"]>;
+    /** Parameter definitions */
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        type: z.ZodEnum<["string", "number", "boolean"]>;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        type: "string" | "number" | "boolean";
+        description: string;
+        required: boolean;
+        default?: unknown;
+    }, {
+        type: "string" | "number" | "boolean";
+        description: string;
+        required?: boolean | undefined;
+        default?: unknown;
+    }>>>;
+    /** Probe timeout in ms */
+    timeout: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    name: string;
+    description: string;
+    capability: "observe" | "interact" | "manage";
+    params?: Record<string, {
+        type: "string" | "number" | "boolean";
+        description: string;
+        required: boolean;
+        default?: unknown;
+    }> | undefined;
+}, {
+    name: string;
+    description: string;
+    capability: "observe" | "interact" | "manage";
+    params?: Record<string, {
+        type: "string" | "number" | "boolean";
+        description: string;
+        required?: boolean | undefined;
+        default?: unknown;
+    }> | undefined;
+    timeout?: number | undefined;
+}>;
+export type ProbeDefinition = z.infer<typeof ProbeDefinition>;
+/** Runbook definition (diagnostic workflow) */
+export declare const RunbookDefinition: z.ZodObject<{
+    /** Category this runbook covers, e.g. "docker" */
+    category: z.ZodString;
+    /** Ordered list of probe names to run */
+    probes: z.ZodArray<z.ZodString, "many">;
+    /** Whether to run probes in parallel */
+    parallel: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    category: string;
+    probes: string[];
+    parallel: boolean;
+}, {
+    category: string;
+    probes: string[];
+    parallel?: boolean | undefined;
+}>;
+export type RunbookDefinition = z.infer<typeof RunbookDefinition>;
+/** Detection rules for auto-discovering installed software */
+export declare const DetectRules: z.ZodObject<{
+    /** Check if these commands exist in PATH */
+    commands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Check if these files exist */
+    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Check if these systemd services exist */
+    services: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    files?: string[] | undefined;
+    commands?: string[] | undefined;
+    services?: string[] | undefined;
+}, {
+    files?: string[] | undefined;
+    commands?: string[] | undefined;
+    services?: string[] | undefined;
+}>;
+export type DetectRules = z.infer<typeof DetectRules>;
+/**
+ * Full pack manifest schema.
+ * Defines a pack's metadata, requirements, probes, runbook, and detection rules.
+ */
+export declare const PackManifest: z.ZodObject<{
+    /** Pack name, e.g. "docker" */
+    name: z.ZodString;
+    /** Semver version */
+    version: z.ZodString;
+    /** Human-readable description */
+    description: z.ZodString;
+    /** Pack author */
+    author: z.ZodOptional<z.ZodString>;
+    /** Code signature (base64) */
+    signature: z.ZodOptional<z.ZodString>;
+    /** System access requirements */
+    requires: z.ZodObject<{
+        /** OS groups needed */
+        groups: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** File paths needed (glob OK) */
+        files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Binaries that must exist in PATH */
+        commands: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Database access if needed */
+        dbRole: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<["postgres", "mysql", "mongodb"]>;
+            access: z.ZodEnum<["read-only", "read-write"]>;
+        }, "strip", z.ZodTypeAny, {
+            type: "postgres" | "mysql" | "mongodb";
+            access: "read-only" | "read-write";
+        }, {
+            type: "postgres" | "mysql" | "mongodb";
+            access: "read-only" | "read-write";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        groups: string[];
+        files: string[];
+        commands: string[];
+        dbRole?: {
+            type: "postgres" | "mysql" | "mongodb";
+            access: "read-only" | "read-write";
+        } | undefined;
+    }, {
+        groups?: string[] | undefined;
+        files?: string[] | undefined;
+        commands?: string[] | undefined;
+        dbRole?: {
+            type: "postgres" | "mysql" | "mongodb";
+            access: "read-only" | "read-write";
+        } | undefined;
+    }>;
+    /** Probes this pack provides */
+    probes: z.ZodArray<z.ZodObject<{
+        /** Probe name, e.g. "containers.list" */
+        name: z.ZodString;
+        /** Human-readable description */
+        description: z.ZodString;
+        /** Capability level required to execute */
+        capability: z.ZodEnum<["observe", "interact", "manage"]>;
+        /** Parameter definitions */
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            type: z.ZodEnum<["string", "number", "boolean"]>;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            type: "string" | "number" | "boolean";
+            description: string;
+            required: boolean;
+            default?: unknown;
+        }, {
+            type: "string" | "number" | "boolean";
+            description: string;
+            required?: boolean | undefined;
+            default?: unknown;
+        }>>>;
+        /** Probe timeout in ms */
+        timeout: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        timeout: number;
+        name: string;
+        description: string;
+        capability: "observe" | "interact" | "manage";
+        params?: Record<string, {
+            type: "string" | "number" | "boolean";
+            description: string;
+            required: boolean;
+            default?: unknown;
+        }> | undefined;
+    }, {
+        name: string;
+        description: string;
+        capability: "observe" | "interact" | "manage";
+        params?: Record<string, {
+            type: "string" | "number" | "boolean";
+            description: string;
+            required?: boolean | undefined;
+            default?: unknown;
+        }> | undefined;
+        timeout?: number | undefined;
+    }>, "many">;
+    /** Default diagnostic runbook */
+    runbook: z.ZodOptional<z.ZodObject<{
+        /** Category this runbook covers, e.g. "docker" */
+        category: z.ZodString;
+        /** Ordered list of probe names to run */
+        probes: z.ZodArray<z.ZodString, "many">;
+        /** Whether to run probes in parallel */
+        parallel: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        category: string;
+        probes: string[];
+        parallel: boolean;
+    }, {
+        category: string;
+        probes: string[];
+        parallel?: boolean | undefined;
+    }>>;
+    /** Rules for auto-detecting this software on the system */
+    detect: z.ZodOptional<z.ZodObject<{
+        /** Check if these commands exist in PATH */
+        commands: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Check if these files exist */
+        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        /** Check if these systemd services exist */
+        services: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        files?: string[] | undefined;
+        commands?: string[] | undefined;
+        services?: string[] | undefined;
+    }, {
+        files?: string[] | undefined;
+        commands?: string[] | undefined;
+        services?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    version: string;
+    description: string;
+    probes: {
+        timeout: number;
+        name: string;
+        description: string;
+        capability: "observe" | "interact" | "manage";
+        params?: Record<string, {
+            type: "string" | "number" | "boolean";
+            description: string;
+            required: boolean;
+            default?: unknown;
+        }> | undefined;
+    }[];
+    requires: {
+        groups: string[];
+        files: string[];
+        commands: string[];
+        dbRole?: {
+            type: "postgres" | "mysql" | "mongodb";
+            access: "read-only" | "read-write";
+        } | undefined;
+    };
+    signature?: string | undefined;
+    author?: string | undefined;
+    runbook?: {
+        category: string;
+        probes: string[];
+        parallel: boolean;
+    } | undefined;
+    detect?: {
+        files?: string[] | undefined;
+        commands?: string[] | undefined;
+        services?: string[] | undefined;
+    } | undefined;
+}, {
+    name: string;
+    version: string;
+    description: string;
+    probes: {
+        name: string;
+        description: string;
+        capability: "observe" | "interact" | "manage";
+        params?: Record<string, {
+            type: "string" | "number" | "boolean";
+            description: string;
+            required?: boolean | undefined;
+            default?: unknown;
+        }> | undefined;
+        timeout?: number | undefined;
+    }[];
+    requires: {
+        groups?: string[] | undefined;
+        files?: string[] | undefined;
+        commands?: string[] | undefined;
+        dbRole?: {
+            type: "postgres" | "mysql" | "mongodb";
+            access: "read-only" | "read-write";
+        } | undefined;
+    };
+    signature?: string | undefined;
+    author?: string | undefined;
+    runbook?: {
+        category: string;
+        probes: string[];
+        parallel?: boolean | undefined;
+    } | undefined;
+    detect?: {
+        files?: string[] | undefined;
+        commands?: string[] | undefined;
+        services?: string[] | undefined;
+    } | undefined;
+}>;
+export type PackManifest = z.infer<typeof PackManifest>;
+//# sourceMappingURL=packs.d.ts.map

package/dist/schemas/packs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packs.d.ts","sourceRoot":"","sources":["../../src/schemas/packs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,uCAAuC;AACvC,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;EAKxB,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D,uCAAuC;AACvC,eAAO,MAAM,iBAAiB;;;;;;;;;EAG5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,4CAA4C;AAC5C,eAAO,MAAM,gBAAgB;IAC3B,uBAAuB;;IAEvB,kCAAkC;;IAElC,uCAAuC;;IAEvC,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEhC,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE,qCAAqC;AACrC,eAAO,MAAM,eAAe;IAC1B,yCAAyC;;IAEzC,iCAAiC;;IAEjC,2CAA2C;;IAE3C,4BAA4B;;;;;;;;;;;;;;;;;IAE5B,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;EAE1B,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,+CAA+C;AAC/C,eAAO,MAAM,iBAAiB;IAC5B,kDAAkD;;IAElD,yCAAyC;;IAEzC,wCAAwC;;;;;;;;;;EAExC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,8DAA8D;AAC9D,eAAO,MAAM,WAAW;IACtB,4CAA4C;;IAE5C,iCAAiC;;IAEjC,4CAA4C;;;;;;;;;;EAE5C,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB,+BAA+B;;IAE/B,qBAAqB;;IAErB,iCAAiC;;IAEjC,kBAAkB;;IAElB,8BAA8B;;IAE9B,iCAAiC;;QA/DjC,uBAAuB;;QAEvB,kCAAkC;;QAElC,uCAAuC;;QAEvC,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2DhC,gCAAgC;;QApDhC,yCAAyC;;QAEzC,iCAAiC;;QAEjC,2CAA2C;;QAE3C,4BAA4B;;;;;;;;;;;;;;;;;QAE5B,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;IA8C1B,iCAAiC;;QAvCjC,kDAAkD;;QAElD,yCAAyC;;QAEzC,wCAAwC;;;;;;;;;;;IAqCxC,2DAA2D;;QA9B3D,4CAA4C;;QAE5C,iCAAiC;;QAEjC,4CAA4C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4B5C,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/schemas/packs.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { CapabilityLevel, DEFAULT_PROBE_TIMEOUT_MS } from '../types/common.js';
+/** Parameter definition for a probe */
+export const ProbeParamDef = z.object({
+    type: z.enum(['string', 'number', 'boolean']),
+    description: z.string(),
+    required: z.boolean().default(false),
+    default: z.unknown().optional(),
+});
+/** Database role access requirement */
+export const DbRoleRequirement = z.object({
+    type: z.enum(['postgres', 'mysql', 'mongodb']),
+    access: z.enum(['read-only', 'read-write']),
+});
+/** System access requirements for a pack */
+export const PackRequirements = z.object({
+    /** OS groups needed */
+    groups: z.array(z.string()).default([]),
+    /** File paths needed (glob OK) */
+    files: z.array(z.string()).default([]),
+    /** Binaries that must exist in PATH */
+    commands: z.array(z.string()).default([]),
+    /** Database access if needed */
+    dbRole: DbRoleRequirement.optional(),
+});
+/** Probe definition within a pack */
+export const ProbeDefinition = z.object({
+    /** Probe name, e.g. "containers.list" */
+    name: z.string(),
+    /** Human-readable description */
+    description: z.string(),
+    /** Capability level required to execute */
+    capability: CapabilityLevel,
+    /** Parameter definitions */
+    params: z.record(ProbeParamDef).optional(),
+    /** Probe timeout in ms */
+    timeout: z.number().default(DEFAULT_PROBE_TIMEOUT_MS),
+});
+/** Runbook definition (diagnostic workflow) */
+export const RunbookDefinition = z.object({
+    /** Category this runbook covers, e.g. "docker" */
+    category: z.string(),
+    /** Ordered list of probe names to run */
+    probes: z.array(z.string()),
+    /** Whether to run probes in parallel */
+    parallel: z.boolean().default(true),
+});
+/** Detection rules for auto-discovering installed software */
+export const DetectRules = z.object({
+    /** Check if these commands exist in PATH */
+    commands: z.array(z.string()).optional(),
+    /** Check if these files exist */
+    files: z.array(z.string()).optional(),
+    /** Check if these systemd services exist */
+    services: z.array(z.string()).optional(),
+});
+/**
+ * Full pack manifest schema.
+ * Defines a pack's metadata, requirements, probes, runbook, and detection rules.
+ */
+export const PackManifest = z.object({
+    /** Pack name, e.g. "docker" */
+    name: z.string(),
+    /** Semver version */
+    version: z.string().regex(/^\d+\.\d+\.\d+$/),
+    /** Human-readable description */
+    description: z.string(),
+    /** Pack author */
+    author: z.string().optional(),
+    /** Code signature (base64) */
+    signature: z.string().optional(),
+    /** System access requirements */
+    requires: PackRequirements,
+    /** Probes this pack provides */
+    probes: z.array(ProbeDefinition),
+    /** Default diagnostic runbook */
+    runbook: RunbookDefinition.optional(),
+    /** Rules for auto-detecting this software on the system */
+    detect: DetectRules.optional(),
+});
+//# sourceMappingURL=packs.js.map

package/dist/schemas/packs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packs.js","sourceRoot":"","sources":["../../src/schemas/packs.ts"],"names":[],"mappings":"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"}

package/dist/schemas/probes.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+/**
+ * Probe request descriptor (Hub → Agent).
+ */
+export declare const ProbeRequest: z.ZodObject<{
+    /** Fully qualified probe name, e.g. "docker.containers.list" */
+    probe: z.ZodString;
+    /** Probe-specific parameters */
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Max time for probe execution in ms */
+    timeout: z.ZodDefault<z.ZodNumber>;
+    /** API key ID or OAuth client ID that initiated the request */
+    requestedBy: z.ZodString;
+    /** Set if this probe is part of a runbook execution */
+    runbookId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    probe: string;
+    requestedBy: string;
+    params?: Record<string, unknown> | undefined;
+    runbookId?: string | undefined;
+}, {
+    probe: string;
+    requestedBy: string;
+    params?: Record<string, unknown> | undefined;
+    timeout?: number | undefined;
+    runbookId?: string | undefined;
+}>;
+export type ProbeRequest = z.infer<typeof ProbeRequest>;
+/**
+ * Probe response (Agent → Hub).
+ */
+export declare const ProbeResponse: z.ZodObject<{
+    /** Echo back which probe ran */
+    probe: z.ZodString;
+    /** Result status */
+    status: z.ZodEnum<["success", "error", "timeout", "unauthorized"]>;
+    /** Probe-specific result data (already scrubbed) */
+    data: z.ZodUnknown;
+    /** How long execution took in ms */
+    durationMs: z.ZodNumber;
+    /** Metadata about the agent/pack that executed the probe */
+    metadata: z.ZodObject<{
+        agentVersion: z.ZodString;
+        packName: z.ZodString;
+        packVersion: z.ZodString;
+        capabilityLevel: z.ZodEnum<["observe", "interact", "manage"]>;
+    }, "strip", z.ZodTypeAny, {
+        agentVersion: string;
+        packName: string;
+        packVersion: string;
+        capabilityLevel: "observe" | "interact" | "manage";
+    }, {
+        agentVersion: string;
+        packName: string;
+        packVersion: string;
+        capabilityLevel: "observe" | "interact" | "manage";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    status: "error" | "success" | "timeout" | "unauthorized";
+    probe: string;
+    durationMs: number;
+    metadata: {
+        agentVersion: string;
+        packName: string;
+        packVersion: string;
+        capabilityLevel: "observe" | "interact" | "manage";
+    };
+    data?: unknown;
+}, {
+    status: "error" | "success" | "timeout" | "unauthorized";
+    probe: string;
+    durationMs: number;
+    metadata: {
+        agentVersion: string;
+        packName: string;
+        packVersion: string;
+        capabilityLevel: "observe" | "interact" | "manage";
+    };
+    data?: unknown;
+}>;
+export type ProbeResponse = z.infer<typeof ProbeResponse>;
+//# sourceMappingURL=probes.d.ts.map

package/dist/schemas/probes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probes.d.ts","sourceRoot":"","sources":["../../src/schemas/probes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;GAEG;AACH,eAAO,MAAM,YAAY;IACvB,gEAAgE;;IAEhE,gCAAgC;;IAEhC,yCAAyC;;IAEzC,+DAA+D;;IAE/D,uDAAuD;;;;;;;;;;;;;;EAEvD,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;GAEG;AACH,eAAO,MAAM,aAAa;IACxB,gCAAgC;;IAEhC,oBAAoB;;IAEpB,oDAAoD;;IAEpD,oCAAoC;;IAEpC,4DAA4D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO5D,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/schemas/probes.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { CapabilityLevel, DEFAULT_PROBE_TIMEOUT_MS, ProbeStatus } from '../types/common.js';
+/**
+ * Probe request descriptor (Hub → Agent).
+ */
+export const ProbeRequest = z.object({
+    /** Fully qualified probe name, e.g. "docker.containers.list" */
+    probe: z.string(),
+    /** Probe-specific parameters */
+    params: z.record(z.unknown()).optional(),
+    /** Max time for probe execution in ms */
+    timeout: z.number().default(DEFAULT_PROBE_TIMEOUT_MS),
+    /** API key ID or OAuth client ID that initiated the request */
+    requestedBy: z.string(),
+    /** Set if this probe is part of a runbook execution */
+    runbookId: z.string().optional(),
+});
+/**
+ * Probe response (Agent → Hub).
+ */
+export const ProbeResponse = z.object({
+    /** Echo back which probe ran */
+    probe: z.string(),
+    /** Result status */
+    status: ProbeStatus,
+    /** Probe-specific result data (already scrubbed) */
+    data: z.unknown(),
+    /** How long execution took in ms */
+    durationMs: z.number(),
+    /** Metadata about the agent/pack that executed the probe */
+    metadata: z.object({
+        agentVersion: z.string(),
+        packName: z.string(),
+        packVersion: z.string(),
+        capabilityLevel: CapabilityLevel,
+    }),
+});
+//# sourceMappingURL=probes.js.map

package/dist/schemas/probes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"probes.js","sourceRoot":"","sources":["../../src/schemas/probes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,wBAAwB,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAE5F;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,gEAAgE;IAChE,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,gCAAgC;IAChC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;IACxC,yCAAyC;IACzC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,wBAAwB,CAAC;IACrD,+DAA+D;IAC/D,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;IACvB,uDAAuD;IACvD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACjC,CAAC,CAAC;AAGH;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC;IACpC,gCAAgC;IAChC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,oBAAoB;IACpB,MAAM,EAAE,WAAW;IACnB,oDAAoD;IACpD,IAAI,EAAE,CAAC,CAAC,OAAO,EAAE;IACjB,oCAAoC;IACpC,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,4DAA4D;IAC5D,QAAQ,EAAE,CAAC,CAAC,MAAM,CAAC;QACjB,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;QACxB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE;QACpB,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE;QACvB,eAAe,EAAE,eAAe;KACjC,CAAC;CACH,CAAC,CAAC"}

package/dist/schemas/protocol.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+/**
+ * WebSocket message envelope.
+ * All agent ↔ hub communication uses this envelope.
+ */
+export declare const MessageEnvelope: z.ZodObject<{
+    /** Unique message ID */
+    id: z.ZodString;
+    /** Message type discriminator */
+    type: z.ZodEnum<["probe.request", "probe.response", "probe.error", "agent.register", "agent.heartbeat", "hub.ack", "hub.reject"]>;
+    /** ISO 8601 timestamp */
+    timestamp: z.ZodString;
+    /** Set after registration */
+    agentId: z.ZodOptional<z.ZodString>;
+    /** Payload signature (base64) */
+    signature: z.ZodString;
+    /** Type-specific payload (validated per type) */
+    payload: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    type: "probe.request" | "probe.response" | "probe.error" | "agent.register" | "agent.heartbeat" | "hub.ack" | "hub.reject";
+    id: string;
+    timestamp: string;
+    signature: string;
+    agentId?: string | undefined;
+    payload?: unknown;
+}, {
+    type: "probe.request" | "probe.response" | "probe.error" | "agent.register" | "agent.heartbeat" | "hub.ack" | "hub.reject";
+    id: string;
+    timestamp: string;
+    signature: string;
+    agentId?: string | undefined;
+    payload?: unknown;
+}>;
+export type MessageEnvelope = z.infer<typeof MessageEnvelope>;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/schemas/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/schemas/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,eAAe;IAC1B,wBAAwB;;IAExB,iCAAiC;;IAEjC,yBAAyB;;IAEzB,6BAA6B;;IAE7B,iCAAiC;;IAEjC,iDAAiD;;;;;;;;;;;;;;;;EAEjD,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/schemas/protocol.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { MessageType } from '../types/common.js';
+/**
+ * WebSocket message envelope.
+ * All agent ↔ hub communication uses this envelope.
+ */
+export const MessageEnvelope = z.object({
+    /** Unique message ID */
+    id: z.string().uuid(),
+    /** Message type discriminator */
+    type: MessageType,
+    /** ISO 8601 timestamp */
+    timestamp: z.string().datetime(),
+    /** Set after registration */
+    agentId: z.string().optional(),
+    /** Payload signature (base64) */
+    signature: z.string(),
+    /** Type-specific payload (validated per type) */
+    payload: z.unknown(),
+});
+//# sourceMappingURL=protocol.js.map

package/dist/schemas/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/schemas/protocol.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;GAGG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACtC,wBAAwB;IACxB,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE;IACrB,iCAAiC;IACjC,IAAI,EAAE,WAAW;IACjB,yBAAyB;IACzB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAChC,6BAA6B;IAC7B,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,iCAAiC;IACjC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,iDAAiD;IACjD,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;CACrB,CAAC,CAAC"}