@kici-dev/orchestrator 0.1.20 → 0.1.21

package/dist/worker/in-memory-job-queue.d.ts

@@ -42,6 +42,23 @@ export declare class InMemoryJobQueue {
      * labels no longer match, or the agent's gate is not satisfied.
      */
     dequeueById(jobId: string, agentLabels: string[], agentMandatoryLabels?: string[]): Promise<QueuedJob | null>;
+    /**
+     * Dequeue the oldest pending job pinned to a specific agent. Mirrors the
+     * DB-backed `JobQueue.dequeueByPinnedAgent` that `Dispatcher.onAgentAvailable`
+     * calls — host-fanout children pinned to THIS agent drain before the generic
+     * label drain. Like the DB version, a pinned job relaxes the label-subset
+     * gate (the agent is its designated runner) and only the JS regex
+     * post-filter is applied.
+     *
+     * The worker receives jobs via direct P2P dispatch and does not currently
+     * pin jobs to agents, so in practice no in-memory job carries a
+     * `pinnedAgentId` and this returns null — `onAgentAvailable` then falls back
+     * to `dequeueForLabels`. Implementing it (rather than leaving it undefined)
+     * is mandatory: `Dispatcher.onAgentAvailable` invokes it unconditionally, so
+     * its absence threw `TypeError: this.queue.dequeueByPinnedAgent is not a
+     * function` as an unhandled rejection that crashed the worker.
+     */
+    dequeueByPinnedAgent(agentId: string, agentLabels?: string[]): Promise<QueuedJob | null>;
     /** Return count of pending jobs. */
     getDepth(): Promise<number>;
     /** No-op — the job is already tracked in `dispatched` from dequeue. */

package/dist/worker/peer-outbox.d.ts

@@ -0,0 +1,36 @@
+import type { JobProgress } from '@kici-dev/engine';
+export interface OutboxRecord {
+    coordUrl: string;
+    message: JobProgress;
+    persistedAt: number;
+}
+/** Durable, at-least-once store of terminal job.progress awaiting coordinator ACK. */
+export declare class PeerOutbox {
+    private readonly dir;
+    private readonly now;
+    private readonly records;
+    constructor(dir: string, now?: () => number);
+    private static coordKey;
+    private static recordKey;
+    private fileFor;
+    loadFromDisk(): Promise<void>;
+    enqueue(coordUrl: string, message: JobProgress): Promise<void>;
+    /**
+     * Synchronous, durably-fsynced enqueue. The terminal job status is on disk
+     * before this method returns — there is no async window in which an
+     * un-flushed write can be lost if the worker process is killed moments
+     * later (e.g. a worker orchestrator that crashes during microVM teardown
+     * right after the job completes). The asynchronous {@link enqueue} is
+     * fire-and-forget at its call site, so its fsync can be dropped when the
+     * event loop never runs again; this variant blocks the (infrequent,
+     * once-per-job-terminal) call path until the bytes are durable instead.
+     */
+    enqueueSync(coordUrl: string, message: JobProgress): void;
+    ack(coordUrl: string, runId: string, jobId: string): Promise<void>;
+    pendingFor(coordUrl: string): OutboxRecord[];
+    prune(ttlMs: number, now?: number): Promise<number>;
+    private fsync;
+    private fsyncDir;
+    private fsyncDirSync;
+}
+//# sourceMappingURL=peer-outbox.d.ts.map

package/dist/worker/worker-outbox-relay.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Relay glue between the worker's in-memory execution tracker and the durable
+ * peer outbox. Extracted so the mapping/replay logic is unit-testable and so
+ * the worker bootstrap stays under the function-length cap.
+ */
+import { type JobProgress } from '@kici-dev/engine';
+import type { StatusUpdate } from './in-memory-execution-tracker.js';
+import type { PeerOutbox } from './peer-outbox.js';
+/** Map a terminal job-level StatusUpdate to the JobProgress to durably relay; null otherwise. */
+export declare function buildTerminalJobProgress(update: StatusUpdate): JobProgress | null;
+/** Re-send every outbox record destined for `url`. Send failures are retried on the next connect. */
+export declare function replayPending(outbox: PeerOutbox, send: (m: JobProgress) => boolean, url: string): void;
+//# sourceMappingURL=worker-outbox-relay.d.ts.map

package/dist/ws/inventory-api.d.ts

@@ -0,0 +1,17 @@
+import { type HostInventoryEntry } from '@kici-dev/engine';
+import type { HostRosterStore } from '../agent/host-roster.js';
+/** Store surface the inventory handlers need (kept narrow for testability). */
+export interface InventoryApiDeps {
+    rosterStore: Pick<HostRosterStore, 'queryInventory' | 'getInventory'>;
+    /** Roster grace window (ms) — the same value runsOnAll's `findMatching` uses. */
+    graceMs: number;
+}
+/**
+ * Build the `inventory.query` handler. Validates the optional label selector
+ * (`include` OR-of-AND groups + `exclude`); an empty selector ⇒ all hosts.
+ * Property filtering is done client-side in the workflow.
+ */
+export declare function createInventoryQueryHandler(deps: InventoryApiDeps): (agentId: string, params: Record<string, unknown>) => Promise<HostInventoryEntry[]>;
+/** Build the `inventory.get` handler — single-host lookup, null when absent. */
+export declare function createInventoryGetHandler(deps: InventoryApiDeps): (agentId: string, params: Record<string, unknown>) => Promise<HostInventoryEntry | null>;
+//# sourceMappingURL=inventory-api.d.ts.map

package/installer-image-digests.json

@@ -1,7 +1,7 @@
 {
-  "version": "0.1.20",
+  "version": "0.1.21",
   "images": {
-    "kici-agent": "sha256:ff28cf8e8fd0405b63797dbd8a972ac328184f53f18fb20443220758769f5fec",
-    "kici-orchestrator": "sha256:f8e27842e455c0fbfa7df564c8adc6505054110610f20b35618c56841bbc905f"
+    "kici-agent": "sha256:28896aa6665887f959765c821d0535f44e6bcaa73b3f45d21c39b6f2f9604c49",
+    "kici-orchestrator": "sha256:d8b1b6306be8beaa973b0828e6d5ffbcb6f10b3c81b2875e37435b4bf140ecbe"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kici-dev/orchestrator",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "description": "Customer-deployable orchestrator for the KiCI CI/CD stack. Receives webhook events (direct or via Platform relay), matches triggers against the lock file, and dispatches jobs to connected agents.",
   "keywords": [
     "ci",
@@ -86,8 +86,8 @@
     "ws": "^8.21.0",
     "yaml": "^2.9.0",
     "zod": "^4.4.3",
-    "@kici-dev/shared": "0.1.20",
-    "@kici-dev/engine": "0.1.20"
+    "@kici-dev/engine": "0.1.21",
+    "@kici-dev/shared": "0.1.21"
   },
   "kici": {
     "metrics": {
@@ -101,7 +101,7 @@
     "@types/archiver": "^8.0.0",
     "@types/dockerode": "^4.0.1",
     "kysely-ctl": "^0.21.0",
-    "@kici-dev/agent": "0.1.20"
+    "@kici-dev/agent": "0.1.21"
   },
   "scripts": {
     "build": "node ../../scripts/build-service.mjs && tsc --emitDeclarationOnly",