@intx/hub-sessions 0.3.0 → 0.4.0

package/dist/ws/sidecar-handler.test-helpers.d.ts

@@ -0,0 +1,38 @@
+import type { HarnessConfig } from "@intx/types/runtime";
+import { createSidecarRouter, type AllocatedSidecarTarget, type SidecarAuthIdentity, type SidecarRouterConfig, type WsHandle } from "./sidecar-handler.js";
+export declare const TEST_IDENTITY: Extract<SidecarAuthIdentity, {
+    kind: "allocated";
+}>;
+export declare const TEST_TARGET: AllocatedSidecarTarget;
+export declare const TEST_CONFIG: HarnessConfig;
+export declare function createMockWs(): WsHandle & {
+    sent: string[];
+    closed: boolean;
+    /**
+     * Resolve once `predicate` holds over the frames sent so far, re-checking
+     * on each send.
+     *
+     * Several of the router's paths write to the socket from a fire-and-forget
+     * continuation -- the mail redelivery retry is one -- so a test that
+     * triggers one has no return value to await. The send is the event.
+     */
+    awaitSent(predicate: (sent: readonly string[]) => boolean): Promise<void>;
+};
+export declare function createAllocatedRouter(config?: Partial<SidecarRouterConfig>): import("./sidecar-handler.js").SidecarRouter & import("./sidecar-handler.js").SidecarAllocationRouter;
+export declare function connectAllocated(router: ReturnType<typeof createSidecarRouter>, agentAddresses?: string[], frameType?: "register" | "reconnect"): Promise<WsHandle & {
+    sent: string[];
+    closed: boolean;
+    /**
+     * Resolve once `predicate` holds over the frames sent so far, re-checking
+     * on each send.
+     *
+     * Several of the router's paths write to the socket from a fire-and-forget
+     * continuation -- the mail redelivery retry is one -- so a test that
+     * triggers one has no return value to await. The send is the event.
+     */
+    awaitSent(predicate: (sent: readonly string[]) => boolean): Promise<void>;
+}>;
+export declare function parsedFrames(ws: {
+    sent: string[];
+}): unknown[];
+export declare function tick(): Promise<void>;

package/dist/ws/sidecar-handler.test-helpers.js

@@ -0,0 +1,95 @@
+import { createSidecarRouter, } from "./sidecar-handler.js";
+export const TEST_IDENTITY = {
+    kind: "allocated",
+    sidecarId: "sc-allocated",
+    allocationId: "alloc-1",
+    tenantId: "tenant-1",
+    anchorRunId: "run_anchor",
+    workflowRunAddress: "run_anchor@tenant.example",
+    generation: 1,
+};
+export const TEST_TARGET = {
+    allocationId: TEST_IDENTITY.allocationId,
+    generation: TEST_IDENTITY.generation,
+};
+export const TEST_CONFIG = {
+    sessionId: "ses-router-test",
+    agentId: "workflow",
+    tenantId: TEST_IDENTITY.tenantId,
+    principalId: "principal-1",
+    agentAddress: TEST_IDENTITY.workflowRunAddress,
+    systemPrompt: "test",
+    tools: [],
+    grants: [],
+    sources: [
+        {
+            id: "test-source",
+            provider: "test",
+            baseURL: "https://api.example.test",
+            credentialId: "test-credential",
+            model: "test",
+        },
+    ],
+    defaultSource: "test-source",
+};
+export function createMockWs() {
+    let waiters = [];
+    return {
+        sent: [],
+        closed: false,
+        send(data) {
+            this.sent.push(data);
+            const waking = waiters;
+            waiters = [];
+            for (const wake of waking)
+                wake();
+        },
+        close() {
+            this.closed = true;
+        },
+        async awaitSent(predicate) {
+            for (;;) {
+                // Re-checked on every pass, so a frame sent before this call resolves
+                // it rather than leaving it waiting for another send.
+                const sent = new Promise((resolve) => {
+                    waiters.push(resolve);
+                });
+                if (predicate(this.sent))
+                    return;
+                await sent;
+            }
+        },
+    };
+}
+export function createAllocatedRouter(config = {}) {
+    const router = createSidecarRouter({
+        authenticateSidecar: async () => TEST_IDENTITY,
+        validateSidecarIdentity: async () => true,
+        hubPublicKey: "a".repeat(64),
+        requestTimeoutMs: 500,
+        ...config,
+    });
+    router.fenceAllocation(TEST_TARGET.allocationId, TEST_TARGET.generation);
+    return router;
+}
+export async function connectAllocated(router, agentAddresses = [], frameType = "register") {
+    const ws = createMockWs();
+    router.handleOpen(ws);
+    router.handleMessage(ws, JSON.stringify({
+        type: frameType,
+        sidecarId: TEST_IDENTITY.sidecarId,
+        token: "token",
+        agentAddresses,
+    }));
+    await tick();
+    return ws;
+}
+export function parsedFrames(ws) {
+    return ws.sent.map((raw) => {
+        const parsed = JSON.parse(raw);
+        return parsed;
+    });
+}
+export function tick() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}

package/dist/ws/sidecar-token-authenticator.js

@@ -1,6 +1,6 @@
 import { and, eq, inArray } from "drizzle-orm";
 import { sha256 } from "@intx/crypto";
-import { sidecar, sidecarAllocation, workflowRun } from "@intx/db/schema";
+import { sidecar, sidecarAllocation, workflowProbe, workflowRun, } from "@intx/db/schema";
 /**
  * Builds an authenticator that verifies a sidecar's presented token
  * against the per-sidecar hash stored on the `sidecar` table. The token
@@ -18,41 +18,55 @@ export function createSidecarCredentialResolver({ db, }) {
         });
         if (row === undefined)
             return null;
-        if (row.credentialScope === "shared") {
-            return { kind: "shared", sidecarId: row.id };
-        }
         const allocation = await db.query.sidecarAllocation.findFirst({
             where: eq(sidecarAllocation.sidecarId, row.id),
         });
-        if (allocation === undefined)
-            return null;
-        if (allocation.status !== "provisioning" &&
-            allocation.status !== "allocated") {
-            return null;
+        if (allocation !== undefined) {
+            if (allocation.status !== "provisioning" &&
+                allocation.status !== "allocated") {
+                return null;
+            }
+            const anchor = await db.query.workflowRun.findFirst({
+                columns: { address: true },
+                where: eq(workflowRun.id, allocation.anchorRunId),
+            });
+            if (anchor?.address === null || anchor?.address === undefined)
+                return null;
+            return {
+                kind: "allocated",
+                sidecarId: row.id,
+                allocationId: allocation.id,
+                tenantId: allocation.tenantId,
+                anchorRunId: allocation.anchorRunId,
+                workflowRunAddress: anchor.address,
+                generation: allocation.generation,
+            };
         }
-        const anchor = await db.query.workflowRun.findFirst({
-            columns: { address: true },
-            where: eq(workflowRun.id, allocation.anchorRunId),
+        const probe = await db.query.workflowProbe.findFirst({
+            where: eq(workflowProbe.sidecarId, row.id),
         });
-        if (anchor?.address === null || anchor?.address === undefined)
+        if (probe === undefined ||
+            (probe.status !== "provisioning" && probe.status !== "probing")) {
             return null;
+        }
         return {
-            kind: "allocated",
+            kind: "probe",
             sidecarId: row.id,
-            allocationId: allocation.id,
-            tenantId: allocation.tenantId,
-            anchorRunId: allocation.anchorRunId,
-            workflowRunAddress: anchor.address,
-            generation: allocation.generation,
+            allocationId: probe.id,
+            tenantId: probe.tenantId,
+            generation: probe.generation,
         };
     }
     async function isCurrent(identity, use) {
-        if (identity.kind === "shared") {
-            const allocation = await db.query.sidecarAllocation.findFirst({
+        if (identity.kind === "probe") {
+            const statuses = use === "registration"
+                ? ["provisioning", "probing"]
+                : ["probing"];
+            const probe = await db.query.workflowProbe.findFirst({
                 columns: { id: true },
-                where: eq(sidecarAllocation.sidecarId, identity.sidecarId),
+                where: and(eq(workflowProbe.id, identity.allocationId), eq(workflowProbe.sidecarId, identity.sidecarId), eq(workflowProbe.tenantId, identity.tenantId), eq(workflowProbe.generation, identity.generation), inArray(workflowProbe.status, statuses)),
             });
-            return allocation === undefined;
+            return probe !== undefined;
         }
         const statuses = use === "registration"
             ? ["provisioning", "allocated"]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@intx/hub-sessions",
   "description": "Session-orchestration substrate for the hub: sidecar router, session, and asset services",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "license": "LGPL-2.1-only",
   "type": "module",
   "exports": {
@@ -17,18 +17,18 @@
     }
   },
   "dependencies": {
-    "@intx/agent": "0.3.0",
-    "@intx/crypto": "0.3.0",
-    "@intx/db": "0.3.0",
-    "@intx/hub-common": "0.3.0",
-    "@intx/log": "0.3.0",
-    "@intx/mime": "0.3.0",
-    "@intx/pack-transport": "0.3.0",
-    "@intx/storage-isogit": "0.3.0",
-    "@intx/tool-packaging": "0.3.0",
-    "@intx/types": "0.3.0",
-    "@intx/workflow": "0.3.0",
-    "@intx/workflow-deploy": "0.3.0",
+    "@intx/agent": "0.4.0",
+    "@intx/crypto": "0.4.0",
+    "@intx/db": "0.4.0",
+    "@intx/hub-common": "0.4.0",
+    "@intx/log": "0.4.0",
+    "@intx/mime": "0.4.0",
+    "@intx/pack-transport": "0.4.0",
+    "@intx/storage-isogit": "0.4.0",
+    "@intx/tool-packaging": "0.4.0",
+    "@intx/types": "0.4.0",
+    "@intx/workflow": "0.4.0",
+    "@intx/workflow-deploy": "0.4.0",
     "arktype": "^2.1.29",
     "drizzle-orm": "^0.45.1",
     "isomorphic-git": "^1.27.2",

package/dist/sidecar-allocation/placement-policy.d.ts

@@ -1,11 +0,0 @@
-import type { SidecarPlacementRequirement, TenantConfig } from "@intx/types";
-export type ResolveEffectiveSidecarPlacementOpts = {
-    /** Tenant configs ordered from the workflow tenant through its ancestors. */
-    readonly tenantConfigs: readonly TenantConfig[];
-};
-/**
- * Resolves the placement fixed onto a new workflow run. An exclusive
- * requirement at any tenant ancestor forces exclusive placement; no tenant
- * configuration can weaken it.
- */
-export declare function resolveEffectiveSidecarPlacement({ tenantConfigs, }: ResolveEffectiveSidecarPlacementOpts): SidecarPlacementRequirement | null;

package/dist/sidecar-allocation/placement-policy.js

@@ -1,21 +0,0 @@
-const EXCLUSIVE_PLACEMENT = Object.freeze({
-    sharing: "exclusive",
-    reuse: "never",
-});
-/**
- * Resolves the placement fixed onto a new workflow run. An exclusive
- * requirement at any tenant ancestor forces exclusive placement; no tenant
- * configuration can weaken it.
- */
-export function resolveEffectiveSidecarPlacement({ tenantConfigs, }) {
-    const tenantPlacements = tenantConfigs.flatMap((config) => config.sidecarPlacement?.sharing === "exclusive"
-        ? [config.sidecarPlacement]
-        : []);
-    if (tenantPlacements.length === 0) {
-        return null;
-    }
-    const tenantRequiresFreshCapacity = tenantPlacements.some((placement) => placement.reuse !== "same-deployment");
-    return tenantRequiresFreshCapacity
-        ? EXCLUSIVE_PLACEMENT
-        : { sharing: "exclusive", reuse: "same-deployment" };
-}