@pellux/goodvibes-sdk 0.38.0 → 1.1.0

package/dist/platform/control-plane/routes/checkpoints.js

@@ -0,0 +1,166 @@
+import { GatewayVerbError } from './gateway-verb-error.js';
+import { readInvocationParams } from './invocation-params.js';
+const CHECKPOINT_KINDS = ['turn', 'agent-run', 'manual'];
+const RETENTION_CLASSES = ['short', 'standard', 'forensic'];
+const CHECKPOINTS_LIST_DEFAULT_LIMIT = 100;
+const CHECKPOINTS_LIST_MAX_LIMIT = 500;
+/**
+ * `WorkspaceCheckpointManager.requireCheckpoint` (../../workspace/checkpoint/manager.ts:599-604,
+ * private) throws a plain `Error` with this exact message shape for an
+ * unknown/gc'd id. `diff`/`restore` both route through it. There is no
+ * public `get(id)` to pre-check existence without a second full manager
+ * call, so this handler matches the message text the manager already
+ * commits to (any manager.ts rewrite of that string is covered by the
+ * bootDaemon proof test — see test/w3-s2-*.test.ts — as a regression net,
+ * not by this string match alone).
+ */
+const NO_CHECKPOINT_FOUND_MARKER = 'no checkpoint found with id';
+async function callOrHonestNotFound(fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes(NO_CHECKPOINT_FOUND_MARKER)) {
+            // Preserve the manager's own message (it already names the specific
+            // missing id) — only the status/code are being upgraded from the
+            // blanket 500 a plain throw would collapse to.
+            throw new GatewayVerbError(message, 'NOT_FOUND', 404);
+        }
+        throw err;
+    }
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function requiredString(value, field) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new GatewayVerbError(`Missing required field: ${field}`, 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function optionalNumber(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n)) {
+        throw new GatewayVerbError(`Invalid number for field: ${field}`, 'INVALID_ARGUMENT', 400);
+    }
+    return n;
+}
+function optionalStringArray(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Array.isArray(value) || !value.every((v) => typeof v === 'string')) {
+        throw new GatewayVerbError('Invalid field: paths must be a string array', 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function optionalBoolean(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'boolean') {
+        throw new GatewayVerbError(`Invalid boolean for field: ${field}`, 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function validateCheckpointKind(value, required) {
+    if (value === undefined || value === null) {
+        if (required)
+            throw new GatewayVerbError('Missing required field: kind', 'INVALID_ARGUMENT', 400);
+        return undefined;
+    }
+    if (typeof value !== 'string' || !CHECKPOINT_KINDS.includes(value)) {
+        throw new GatewayVerbError(`Invalid kind: ${String(value)} (expected one of ${CHECKPOINT_KINDS.join(', ')})`, 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function validateRetentionClass(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string' || !RETENTION_CLASSES.includes(value)) {
+        throw new GatewayVerbError(`Invalid retentionClass: ${String(value)} (expected one of ${RETENTION_CLASSES.join(', ')})`, 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function clampLimit(raw) {
+    if (raw === undefined || raw === null)
+        return CHECKPOINTS_LIST_DEFAULT_LIMIT;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new GatewayVerbError(`Invalid limit: ${String(raw)}`, 'INVALID_ARGUMENT', 400);
+    }
+    return Math.min(Math.floor(n), CHECKPOINTS_LIST_MAX_LIMIT);
+}
+export function createCheckpointsListHandler(manager) {
+    return async (invocation) => {
+        const params = readInvocationParams(invocation);
+        const kind = validateCheckpointKind(params.kind, false);
+        const since = optionalNumber(params.since, 'since');
+        const limit = clampLimit(params.limit);
+        const checkpoints = await manager.list({ kind, since, limit });
+        return { checkpoints };
+    };
+}
+export function createCheckpointsCreateHandler(manager) {
+    return async (invocation) => {
+        const body = readInvocationParams(invocation);
+        const kind = validateCheckpointKind(body.kind, true);
+        if (!kind)
+            throw new GatewayVerbError('Missing required field: kind', 'INVALID_ARGUMENT', 400);
+        const checkpoint = await manager.create({
+            kind,
+            label: optionalString(body.label),
+            retentionClass: validateRetentionClass(body.retentionClass),
+            turnId: optionalString(body.turnId),
+            agentId: optionalString(body.agentId),
+            paths: optionalStringArray(body.paths),
+        });
+        // `create` returns null when the workspace tree is unchanged since the
+        // parent checkpoint (manager.ts:349-357) — an honest no-op, not an
+        // error and not a fabricated checkpoint record.
+        return { checkpoint, noop: checkpoint === null };
+    };
+}
+export function createCheckpointsDiffHandler(manager) {
+    return async (invocation) => {
+        const params = readInvocationParams(invocation);
+        const a = requiredString(params.a, 'a');
+        const b = optionalString(params.b);
+        const diff = await callOrHonestNotFound(() => manager.diff(a, b));
+        return { diff };
+    };
+}
+export function createCheckpointsRestoreHandler(manager) {
+    return async (invocation) => {
+        const body = readInvocationParams(invocation);
+        const id = requiredString(body.id, 'id');
+        const result = await callOrHonestNotFound(() => manager.restore(id, {
+            paths: optionalStringArray(body.paths),
+            safetyCheckpoint: optionalBoolean(body.safetyCheckpoint, 'safetyCheckpoint'),
+        }));
+        return { result };
+    };
+}
+/**
+ * Attach the `checkpoints.*` handlers to the descriptors already registered
+ * (without a handler) from ../method-catalog-control-core.ts's static
+ * builtin array. Call once, at RuntimeServices construction time, after
+ * `workspaceCheckpointManager` exists. A missing descriptor is a silent
+ * no-op — see routes/fleet.ts's `registerFleetGatewayMethods` for the same
+ * rationale.
+ */
+export function registerCheckpointGatewayMethods(catalog, manager) {
+    const listDescriptor = catalog.get('checkpoints.list');
+    if (listDescriptor)
+        catalog.register(listDescriptor, createCheckpointsListHandler(manager), { replace: true });
+    const createDescriptor = catalog.get('checkpoints.create');
+    if (createDescriptor)
+        catalog.register(createDescriptor, createCheckpointsCreateHandler(manager), { replace: true });
+    const diffDescriptor = catalog.get('checkpoints.diff');
+    if (diffDescriptor)
+        catalog.register(diffDescriptor, createCheckpointsDiffHandler(manager), { replace: true });
+    const restoreDescriptor = catalog.get('checkpoints.restore');
+    if (restoreDescriptor)
+        catalog.register(restoreDescriptor, createCheckpointsRestoreHandler(manager), { replace: true });
+}

package/dist/platform/control-plane/routes/fleet.d.ts

@@ -0,0 +1,53 @@
+/**
+ * routes/fleet.ts
+ *
+ * `fleet.snapshot` / `fleet.list` gateway-method handlers (see CHANGELOG 1.0.0) over the
+ * ALREADY daemon-resident `ProcessRegistry` (createProcessRegistry(),
+ * ../../runtime/fleet/registry.ts:204, constructed + exposed on
+ * RuntimeServices at ../../runtime/services.ts:712/:242). This is thin verb
+ * registration, not new machinery: every call is a direct pass-through to
+ * `registry.query()`, the registry's own cheap aggregate-on-read scan.
+ *
+ * Wired via `GatewayMethodCatalog.register(descriptor, handler)` — the SAME
+ * mechanism the plugin API already uses (../../plugins/api.ts
+ * `registerGatewayMethod`) — rather than a new REST path in the external
+ * `@pellux/goodvibes-daemon-sdk` package or a change to
+ * ../../daemon/http/router.ts (both out of this brief's file ownership).
+ * The registered handler is reached over real HTTP today via the existing
+ * generic invoke endpoint `POST /api/control-plane/methods/{methodId}/invoke`
+ * (daemon-sdk/src/control-routes.ts `invokeGatewayMethod`).
+ *
+ * Descriptors live in ../method-catalog-control-core.ts (so
+ * `buildOperatorContract` / api.md / contract-artifact generation see them
+ * whether or not a handler has been attached yet); `registerFleetGatewayMethods`
+ * below attaches the handler at RuntimeServices construction time
+ * (../../runtime/services.ts, right after `processRegistry` exists).
+ */
+import type { GatewayMethodCatalog } from '../method-catalog.js';
+import type { GatewayMethodHandler } from '../method-catalog-shared.js';
+import type { ProcessRegistry } from '../../runtime/fleet/types.js';
+/**
+ * `fleet.snapshot` payload cap: the registry's
+ * `query()` is a cheap O(n) in-memory scan, but the wire response must not
+ * grow unbounded with fleet size. Nodes beyond this cap are dropped (newest
+ * activity first is NOT guaranteed here — see `truncated`/`totalCount` so a
+ * caller that needs the full set knows to page via `fleet.list` instead).
+ */
+export declare const FLEET_SNAPSHOT_NODE_CAP = 2000;
+export declare const FLEET_LIST_DEFAULT_LIMIT = 100;
+export declare const FLEET_LIST_MAX_LIMIT = 500;
+/** Structural dep — only the read surface `fleet.*` needs. */
+export type FleetQueryOnlyRegistry = Pick<ProcessRegistry, 'query'>;
+export declare function createFleetSnapshotHandler(registry: FleetQueryOnlyRegistry): GatewayMethodHandler;
+export declare function createFleetListHandler(registry: FleetQueryOnlyRegistry): GatewayMethodHandler;
+/**
+ * Attach the `fleet.snapshot` / `fleet.list` handlers to the descriptors
+ * already registered (without a handler) from
+ * ../method-catalog-control-core.ts's static builtin array. Call once, at
+ * RuntimeServices construction time, after `processRegistry` exists.
+ * A missing descriptor (contract/registration drift) is a silent no-op
+ * rather than a throw — construction must never fail because a wire verb
+ * failed to register; the operator-contract gates catch a real drift.
+ */
+export declare function registerFleetGatewayMethods(catalog: GatewayMethodCatalog, registry: FleetQueryOnlyRegistry): void;
+//# sourceMappingURL=fleet.d.ts.map

package/dist/platform/control-plane/routes/fleet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fleet.d.ts","sourceRoot":"","sources":["../../../../src/platform/control-plane/routes/fleet.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAIV,eAAe,EAEhB,MAAM,8BAA8B,CAAC;AAKtC;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,OAAO,CAAC;AAE5C,eAAO,MAAM,wBAAwB,MAAM,CAAC;AAC5C,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAyExC,8DAA8D;AAC9D,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,eAAe,EAAE,OAAO,CAAC,CAAC;AAEpE,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,sBAAsB,GAAG,oBAAoB,CAejG;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,sBAAsB,GAAG,oBAAoB,CAuC7F;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,oBAAoB,EAAE,QAAQ,EAAE,sBAAsB,GAAG,IAAI,CASjH"}

package/dist/platform/control-plane/routes/fleet.js

@@ -0,0 +1,153 @@
+import { paginateItems } from '@pellux/goodvibes-daemon-sdk';
+import { GatewayVerbError } from './gateway-verb-error.js';
+import { readInvocationParams } from './invocation-params.js';
+/**
+ * `fleet.snapshot` payload cap: the registry's
+ * `query()` is a cheap O(n) in-memory scan, but the wire response must not
+ * grow unbounded with fleet size. Nodes beyond this cap are dropped (newest
+ * activity first is NOT guaranteed here — see `truncated`/`totalCount` so a
+ * caller that needs the full set knows to page via `fleet.list` instead).
+ */
+export const FLEET_SNAPSHOT_NODE_CAP = 2000;
+export const FLEET_LIST_DEFAULT_LIMIT = 100;
+export const FLEET_LIST_MAX_LIMIT = 500;
+const PROCESS_KINDS = [
+    'agent',
+    'wrfc-chain',
+    'wrfc-subtask',
+    'workflow',
+    'trigger',
+    'schedule',
+    'watcher',
+    'background-process',
+    'workstream',
+    'phase',
+    'work-item',
+    'code-index',
+];
+const PROCESS_STATES = [
+    'thinking',
+    'executing-tool',
+    'awaiting-approval',
+    'streaming',
+    'stalled',
+    'retrying',
+    'done',
+    'failed',
+    'killed',
+    'interrupted',
+    'idle',
+    'queued',
+    'paused',
+];
+function asStringArray(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (Array.isArray(value))
+        return value.filter((v) => typeof v === 'string');
+    if (typeof value === 'string')
+        return value.split(',').map((v) => v.trim()).filter(Boolean);
+    return undefined;
+}
+function readFleetQueryFilter(query) {
+    if (!query)
+        return undefined;
+    const rawKinds = asStringArray(query.kinds);
+    const rawStates = asStringArray(query.states);
+    let kinds;
+    if (rawKinds) {
+        const invalid = rawKinds.filter((k) => !PROCESS_KINDS.includes(k));
+        if (invalid.length > 0) {
+            throw new GatewayVerbError(`Unknown fleet kind(s): ${invalid.join(', ')}`, 'INVALID_ARGUMENT', 400);
+        }
+        kinds = rawKinds;
+    }
+    let states;
+    if (rawStates) {
+        const invalid = rawStates.filter((s) => !PROCESS_STATES.includes(s));
+        if (invalid.length > 0) {
+            throw new GatewayVerbError(`Unknown fleet state(s): ${invalid.join(', ')}`, 'INVALID_ARGUMENT', 400);
+        }
+        states = rawStates;
+    }
+    if (!kinds && !states)
+        return undefined;
+    return { ...(kinds ? { kinds } : {}), ...(states ? { states } : {}) };
+}
+function clampLimit(raw, fallback, max) {
+    if (raw === undefined || raw === null)
+        return fallback;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new GatewayVerbError(`Invalid limit: ${String(raw)}`, 'INVALID_ARGUMENT', 400);
+    }
+    return Math.min(Math.floor(n), max);
+}
+export function createFleetSnapshotHandler(registry) {
+    return (invocation) => {
+        const filter = readFleetQueryFilter(readInvocationParams(invocation));
+        const snapshot = registry.query(filter);
+        const truncated = snapshot.nodes.length > FLEET_SNAPSHOT_NODE_CAP;
+        const nodes = truncated
+            ? snapshot.nodes.slice(0, FLEET_SNAPSHOT_NODE_CAP)
+            : snapshot.nodes;
+        return {
+            capturedAt: snapshot.capturedAt,
+            nodes,
+            truncated,
+            totalCount: snapshot.nodes.length,
+        };
+    };
+}
+export function createFleetListHandler(registry) {
+    return (invocation) => {
+        const params = readInvocationParams(invocation);
+        const filter = readFleetQueryFilter(params);
+        const limit = clampLimit(params.limit, FLEET_LIST_DEFAULT_LIMIT, FLEET_LIST_MAX_LIMIT);
+        const rawCursor = typeof params.cursor === 'string' ? params.cursor : null;
+        const snapshot = registry.query(filter);
+        // Sort key and recovery key MUST agree (mirrors sessions.search's
+        // sortSessions-then-paginateItems pattern in session-search.ts): the array
+        // is sorted newest-first by startedAt (id tiebreak for determinism when
+        // two nodes share a timestamp, or neither has started), and paginateItems
+        // is handed that SAME startedAt extractor with { descending: true }. A
+        // node's `startedAt` is optional (not-yet-started processes), so absent
+        // values are normalized to 0 for both the sort and the recovery key —
+        // otherwise `paginateItems`' deleted-cursor recovery (which does a
+        // findIndex assuming the array is actually ordered by the field it is
+        // given) would search a startedAt-ordered predicate over an array that
+        // was really sorted by id, silently skipping or repeating nodes once a
+        // process is gc'd between pages.
+        const startedAtOf = (node) => node.startedAt ?? 0;
+        const sorted = [...snapshot.nodes].sort((a, b) => startedAtOf(b) - startedAtOf(a) || a.id.localeCompare(b.id));
+        const page = paginateItems(sorted, limit, rawCursor, (node) => node.id, startedAtOf, { descending: true });
+        if ('error' in page) {
+            throw new GatewayVerbError(page.error, 'INVALID_CURSOR', 400);
+        }
+        return {
+            items: page.items,
+            nextCursor: page.nextCursor,
+            hasMore: page.hasMore,
+            capturedAt: snapshot.capturedAt,
+        };
+    };
+}
+/**
+ * Attach the `fleet.snapshot` / `fleet.list` handlers to the descriptors
+ * already registered (without a handler) from
+ * ../method-catalog-control-core.ts's static builtin array. Call once, at
+ * RuntimeServices construction time, after `processRegistry` exists.
+ * A missing descriptor (contract/registration drift) is a silent no-op
+ * rather than a throw — construction must never fail because a wire verb
+ * failed to register; the operator-contract gates catch a real drift.
+ */
+export function registerFleetGatewayMethods(catalog, registry) {
+    const snapshotDescriptor = catalog.get('fleet.snapshot');
+    if (snapshotDescriptor) {
+        catalog.register(snapshotDescriptor, createFleetSnapshotHandler(registry), { replace: true });
+    }
+    const listDescriptor = catalog.get('fleet.list');
+    if (listDescriptor) {
+        catalog.register(listDescriptor, createFleetListHandler(registry), { replace: true });
+    }
+}

package/dist/platform/control-plane/routes/gateway-verb-error.d.ts

@@ -0,0 +1,30 @@
+/**
+ * gateway-verb-error.ts
+ *
+ * (fleet.*, checkpoints.*, sessions.search — see CHANGELOG 1.0.0): a structured error for
+ * gateway methods registered with a direct handler via
+ * `GatewayMethodCatalog.register(descriptor, handler)`.
+ *
+ * WHY THIS EXISTS: `invokeGatewayMethodCall` (../../daemon/control-plane.ts)
+ * dispatches a handler-bearing method via `catalog.invoke()` and, on ANY
+ * thrown error, collapses it to a blanket `{ status: 500 }` — there was no
+ * prior handler-registered verb that needed an honest non-500 status (the
+ * only prior consumer of `register(descriptor, handler)` is the plugin API,
+ * whose tool-call errors are swallowed into a `{success:false}` payload, not
+ * an HTTP status). checkpoints.diff/restore need an honest 404 for an
+ * unknown/gc'd checkpoint id (see routes/checkpoints.ts), and invalid
+ * pagination cursors need an honest 400 (fleet.list, sessions.search) — a
+ * blanket 500 would misreport caller error as server error.
+ *
+ * This mirrors the existing `SDKErrorCodes.SESSION_CLOSED` convention used by
+ * the plain-REST session routes (`callOrSessionClosed`,
+ * ../../../daemon-sdk/src/runtime-session-routes.ts), generalized to any
+ * status/code pair instead of one hardcoded to 409/SESSION_CLOSED.
+ */
+export declare class GatewayVerbError extends Error {
+    readonly code: string;
+    readonly status: number;
+    constructor(message: string, code: string, status: number);
+}
+export declare function isGatewayVerbError(error: unknown): error is GatewayVerbError;
+//# sourceMappingURL=gateway-verb-error.d.ts.map

package/dist/platform/control-plane/routes/gateway-verb-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gateway-verb-error.d.ts","sourceRoot":"","sources":["../../../../src/platform/control-plane/routes/gateway-verb-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAM1D;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAE5E"}

package/dist/platform/control-plane/routes/gateway-verb-error.js

@@ -0,0 +1,36 @@
+/**
+ * gateway-verb-error.ts
+ *
+ * (fleet.*, checkpoints.*, sessions.search — see CHANGELOG 1.0.0): a structured error for
+ * gateway methods registered with a direct handler via
+ * `GatewayMethodCatalog.register(descriptor, handler)`.
+ *
+ * WHY THIS EXISTS: `invokeGatewayMethodCall` (../../daemon/control-plane.ts)
+ * dispatches a handler-bearing method via `catalog.invoke()` and, on ANY
+ * thrown error, collapses it to a blanket `{ status: 500 }` — there was no
+ * prior handler-registered verb that needed an honest non-500 status (the
+ * only prior consumer of `register(descriptor, handler)` is the plugin API,
+ * whose tool-call errors are swallowed into a `{success:false}` payload, not
+ * an HTTP status). checkpoints.diff/restore need an honest 404 for an
+ * unknown/gc'd checkpoint id (see routes/checkpoints.ts), and invalid
+ * pagination cursors need an honest 400 (fleet.list, sessions.search) — a
+ * blanket 500 would misreport caller error as server error.
+ *
+ * This mirrors the existing `SDKErrorCodes.SESSION_CLOSED` convention used by
+ * the plain-REST session routes (`callOrSessionClosed`,
+ * ../../../daemon-sdk/src/runtime-session-routes.ts), generalized to any
+ * status/code pair instead of one hardcoded to 409/SESSION_CLOSED.
+ */
+export class GatewayVerbError extends Error {
+    code;
+    status;
+    constructor(message, code, status) {
+        super(message);
+        this.name = 'GatewayVerbError';
+        this.code = code;
+        this.status = status;
+    }
+}
+export function isGatewayVerbError(error) {
+    return error instanceof GatewayVerbError;
+}

package/dist/platform/control-plane/routes/index.d.ts

@@ -1,8 +1,2 @@
-export { dispatchAutomationRoutes } from './automation.js';
-export { dispatchSessionRoutes } from './sessions.js';
-export { dispatchTaskRoutes } from './tasks.js';
-export { dispatchOperatorRoutes } from './operator.js';
-export { dispatchRemoteRoutes } from './remote.js';
 export { dispatchDaemonApiRoutes } from './api-router.js';
-export type { DaemonApiRouteHandlers } from './context.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/platform/control-plane/routes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/control-plane/routes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAC1D,YAAY,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/platform/control-plane/routes/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/platform/control-plane/routes/index.js

@@ -1,6 +1,6 @@
-export { dispatchAutomationRoutes } from './automation.js';
-export { dispatchSessionRoutes } from './sessions.js';
-export { dispatchTaskRoutes } from './tasks.js';
-export { dispatchOperatorRoutes } from './operator.js';
-export { dispatchRemoteRoutes } from './remote.js';
+// The live daemon route dispatch is daemon-sdk's; this barrel re-exports it.
+// The former sdk-local dispatcher copies (automation/tasks/operator/remote/
+// sessions + their context types) were a superseded, unreachable parallel —
+// deleted in the session-spine integration cleanup (see CHANGELOG 1.0.0; 0 callers, 0 api.md
+// presence; every test imports the daemon-sdk originals). Pay-its-way rule.
 export { dispatchDaemonApiRoutes } from './api-router.js';

package/dist/platform/control-plane/routes/invocation-params.d.ts

@@ -0,0 +1,23 @@
+/**
+ * routes/invocation-params.ts
+ *
+ * (see CHANGELOG 1.0.0, post-S1 alignment) — one params view for the handler-registered
+ * verbs (fleet.*, checkpoints.*, sessions.search).
+ *
+ * S1's invoke-layer input gate (invoke-input-validation.ts, wired in
+ * daemon/control-plane.ts invokeGatewayMethodCall) validates the invoke BODY
+ * against a handler verb's typed inputSchema — a method with no http binding
+ * is body-carrying by that gate's definition. So the BODY is the canonical,
+ * schema-validated params channel for these verbs, and callers should put
+ * params there.
+ *
+ * The generic invoke envelope ({ query?, body }) still carries a `query`
+ * record, so this helper folds it in as a FALLBACK (body keys win). Query-
+ * supplied values bypass S1's schema gate, but every one of these handlers
+ * performs its own full validation with honest 400s (GatewayVerbError), so
+ * nothing unchecked reaches a manager either way.
+ */
+import type { GatewayMethodInvocation } from '../method-catalog-shared.js';
+/** Merged params for a handler-registered verb: query as fallback, body wins. */
+export declare function readInvocationParams(invocation: GatewayMethodInvocation): Record<string, unknown>;
+//# sourceMappingURL=invocation-params.d.ts.map

package/dist/platform/control-plane/routes/invocation-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invocation-params.d.ts","sourceRoot":"","sources":["../../../../src/platform/control-plane/routes/invocation-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAQ3E,iFAAiF;AACjF,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,uBAAuB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEjG"}

package/dist/platform/control-plane/routes/invocation-params.js

@@ -0,0 +1,9 @@
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+/** Merged params for a handler-registered verb: query as fallback, body wins. */
+export function readInvocationParams(invocation) {
+    return { ...asRecord(invocation.query), ...asRecord(invocation.body) };
+}

package/dist/platform/control-plane/routes/push.d.ts

@@ -0,0 +1,26 @@
+/**
+ * routes/push.ts
+ *
+ * Attaches the `push.*` gateway-method handlers to the descriptors declared in
+ * ../method-catalog-push.ts. Same mechanism fleet.* uses:
+ * `catalog.register(descriptor, handler)`, reached over real HTTP through the
+ * generic `/api/control-plane/methods/{id}/invoke` endpoint — no new REST route
+ * in the external daemon-sdk package, no router change.
+ *
+ * Every write is scoped to the authenticated principal (the operator identity
+ * the invoke layer resolved), so one operator can neither read, delete, nor
+ * test another operator's registered devices.
+ */
+import type { GatewayMethodCatalog } from '../method-catalog.js';
+import type { PushService } from '../../push/index.js';
+/** The narrow slice of PushService these verbs need. */
+export type PushGatewayService = Pick<PushService, 'getPublicKey' | 'subscribe' | 'listSubscriptions' | 'unsubscribe' | 'verify'>;
+/**
+ * Attach the `push.*` handlers to their already-cataloged descriptors. Call
+ * once, at RuntimeServices construction time, after the PushService exists. A
+ * missing descriptor (contract/registration drift) is a silent no-op rather
+ * than a throw — construction must never fail because one wire verb failed to
+ * register; the operator-contract gates catch a real drift.
+ */
+export declare function registerPushGatewayMethods(catalog: GatewayMethodCatalog, service: PushGatewayService): void;
+//# sourceMappingURL=push.d.ts.map

package/dist/platform/control-plane/routes/push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../../../../src/platform/control-plane/routes/push.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAKvD,wDAAwD;AACxD,MAAM,MAAM,kBAAkB,GAAG,IAAI,CACnC,WAAW,EACX,cAAc,GAAG,WAAW,GAAG,mBAAmB,GAAG,aAAa,GAAG,QAAQ,CAC9E,CAAC;AAkGF;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAO3G"}

package/dist/platform/control-plane/routes/push.js

@@ -0,0 +1,104 @@
+import { GatewayVerbError } from './gateway-verb-error.js';
+import { readInvocationParams } from './invocation-params.js';
+function requirePrincipal(invocation) {
+    const principalId = invocation.context.principalId;
+    if (!principalId) {
+        throw new GatewayVerbError('Push verbs require an authenticated principal', 'UNAUTHENTICATED', 401);
+    }
+    return principalId;
+}
+function requireString(value, field) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new GatewayVerbError(`Missing or invalid ${field}`, 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function requireHttpsEndpoint(value) {
+    const endpoint = requireString(value, 'endpoint');
+    let parsed;
+    try {
+        parsed = new URL(endpoint);
+    }
+    catch {
+        throw new GatewayVerbError('endpoint is not a valid URL', 'INVALID_ARGUMENT', 400);
+    }
+    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+        throw new GatewayVerbError('endpoint must be an http(s) URL', 'INVALID_ARGUMENT', 400);
+    }
+    return endpoint;
+}
+function requireKeys(value) {
+    if (value === null || typeof value !== 'object') {
+        throw new GatewayVerbError('Missing subscription keys', 'INVALID_ARGUMENT', 400);
+    }
+    const keys = value;
+    return {
+        p256dh: requireString(keys.p256dh, 'keys.p256dh'),
+        auth: requireString(keys.auth, 'keys.auth'),
+    };
+}
+function createVapidGetHandler(service) {
+    return async () => ({ publicKey: await service.getPublicKey() });
+}
+function createSubscribeHandler(service) {
+    return async (invocation) => {
+        const principalId = requirePrincipal(invocation);
+        const params = readInvocationParams(invocation);
+        const endpoint = requireHttpsEndpoint(params.endpoint);
+        const keys = requireKeys(params.keys);
+        const subscription = await service.subscribe({ principalId, endpoint, keys });
+        return { subscription };
+    };
+}
+function createListHandler(service) {
+    return async (invocation) => {
+        const principalId = requirePrincipal(invocation);
+        return { subscriptions: await service.listSubscriptions(principalId) };
+    };
+}
+function createDeleteHandler(service) {
+    return async (invocation) => {
+        const principalId = requirePrincipal(invocation);
+        const params = readInvocationParams(invocation);
+        const subscriptionId = requireString(params.subscriptionId, 'subscriptionId');
+        const deleted = await service.unsubscribe(subscriptionId, principalId);
+        if (!deleted) {
+            throw new GatewayVerbError('Unknown push subscription', 'SUBSCRIPTION_NOT_FOUND', 404);
+        }
+        return { subscriptionId, deleted: true };
+    };
+}
+function createVerifyHandler(service) {
+    return async (invocation) => {
+        const principalId = requirePrincipal(invocation);
+        const params = readInvocationParams(invocation);
+        const subscriptionId = requireString(params.subscriptionId, 'subscriptionId');
+        const receipt = await service.verify(subscriptionId, principalId);
+        if (!receipt) {
+            throw new GatewayVerbError('Unknown push subscription', 'SUBSCRIPTION_NOT_FOUND', 404);
+        }
+        return { receipt };
+    };
+}
+const PUSH_HANDLER_FACTORIES = {
+    'push.vapid.get': createVapidGetHandler,
+    'push.subscriptions.create': createSubscribeHandler,
+    'push.subscriptions.list': createListHandler,
+    'push.subscriptions.delete': createDeleteHandler,
+    'push.subscriptions.verify': createVerifyHandler,
+};
+/**
+ * Attach the `push.*` handlers to their already-cataloged descriptors. Call
+ * once, at RuntimeServices construction time, after the PushService exists. A
+ * missing descriptor (contract/registration drift) is a silent no-op rather
+ * than a throw — construction must never fail because one wire verb failed to
+ * register; the operator-contract gates catch a real drift.
+ */
+export function registerPushGatewayMethods(catalog, service) {
+    for (const [methodId, factory] of Object.entries(PUSH_HANDLER_FACTORIES)) {
+        const descriptor = catalog.get(methodId);
+        if (descriptor) {
+            catalog.register(descriptor, factory(service), { replace: true });
+        }
+    }
+}