@capybara-hq/kernel 0.1.0-rc.24 → 0.1.0-rc.26

package/dist/inbox/platform-inbox.service.d.ts

@@ -8,11 +8,6 @@ import type { PlatformNoticeDetails } from "./platform-notices.js";
 export declare const PLATFORM_INBOX_MAX_ITEMS = 100;
 /** The most open scope sync failures one read takes. */
 export declare const SCOPE_SYNC_FAILURES_LIST_MAX = 200;
-/**
- * A platform components migration run unfinished this long after its start is stuck (its worker
- * stopped mid-run; a run takes seconds, and the next one starts at the next worker start or day).
- */
-export declare const MIGRATION_RUN_STUCK_MS: number;
 /**
  * An open failure of the plugin scope sync: its last attempt to install the plugin in the org, to
  * uninstall it, or to install the dependencies a platform update added (`dependencies`) failed,
@@ -34,18 +29,6 @@ export interface ScopeSyncFailureView {
     message: string;
     failedAt: string;
 }
-/**
- * The latest platform components migration run (`platform_migration_runs`) when it needs a look:
- * finished with catalog items whose components could not be written (`itemsFailed`,
- * `<name>@<version>`), or `stuck` (unfinished {@link MIGRATION_RUN_STUCK_MS} after its start).
- */
-export interface MigrationRunView {
-    id: string;
-    startedAt: string;
-    finishedAt: string | null;
-    stuck: boolean;
-    itemsFailed: string[];
-}
 /**
  * One item of the super admin's inbox (by `type`). Nothing is decided in the inbox: each item is
  * acted on where it lives (the web links to it).
@@ -56,7 +39,6 @@ export interface MigrationRunView {
  * - `org_upload_pending`: an org-owned plugin whose uploaded version (with an extension) waits for
  *   the super admin in 待确认 (ruling P3-22; confirmed or rejected there), `id` = the item's;
  * - `scope_sync_failed`: an open scope sync failure, `id` = `<itemId>/<orgId>`;
- * - `platform_migration`: the latest migration run, failed items or stuck, `id` = the run's;
  * - `ownership_transferred`: a deleted org's shared item now belongs to the platform, until a
  *   super admin dismisses it (`POST admin/inbox/notices/:id/dismiss`).
  */
@@ -80,11 +62,6 @@ export type PlatformInboxItem = {
     id: string;
     createdAt: string;
     failure: ScopeSyncFailureView;
-} | {
-    type: "platform_migration";
-    id: string;
-    createdAt: string;
-    run: MigrationRunView;
 } | {
     type: "ownership_transferred";
     id: string;
@@ -92,7 +69,7 @@ export type PlatformInboxItem = {
     notice: PlatformNoticeView;
 };
 /** Every {@link PlatformInboxItem} type, in the order the admin overview lists them. */
-export declare const PLATFORM_INBOX_TYPES: readonly ["catalog_request", "permission_confirmation", "org_upload_pending", "scope_sync_failed", "platform_migration", "ownership_transferred"];
+export declare const PLATFORM_INBOX_TYPES: readonly ["catalog_request", "permission_confirmation", "org_upload_pending", "scope_sync_failed", "ownership_transferred"];
 /** How many items of each type wait: every type, zeros included. */
 export type PlatformInboxCounts = Record<PlatformInboxItem["type"], number>;
 /** An open platform notice (`platform_notices`, kind `ownership_transferred`). */
@@ -116,8 +93,8 @@ export interface PlatformInboxView {
 /**
  * The super admin's inbox (plugin scope spec §5.1 rule 5, §13.5): what waits on the platform,
  * gathered from the sources the admin pages read (the 待确认 tab's requests and permission
- * confirmations), plus the scope sync's open failures and the platform components migration's
- * latest run. Stateless, read live from PG.
+ * confirmations), plus the scope sync's open failures and the platform notices. Stateless, read
+ * live from PG.
  */
 export declare class PlatformInboxService {
     private readonly requests;
@@ -148,10 +125,4 @@ export declare class PlatformInboxService {
     private countScopeSyncFailures;
     /** The open scope sync failures ({@link failureRows}), newest first. */
     private scopeSyncFailures;
-    /**
-     * The latest migration run when it needs a look (see {@link MigrationRunView}); null when it
-     * finished without failed items, is still running, or there was none. An earlier run's failure
-     * is not shown: each run tries every unwritten item again.
-     */
-    private migrationRun;
 }

package/dist/inbox/platform-inbox.service.js

@@ -17,11 +17,6 @@ import { KernelDb } from "../infra/database/kernel-db.js";
 export const PLATFORM_INBOX_MAX_ITEMS = 100;
 /** The most open scope sync failures one read takes. */
 export const SCOPE_SYNC_FAILURES_LIST_MAX = 200;
-/**
- * A platform components migration run unfinished this long after its start is stuck (its worker
- * stopped mid-run; a run takes seconds, and the next one starts at the next worker start or day).
- */
-export const MIGRATION_RUN_STUCK_MS = 60 * 60_000;
 /** Plugin install statuses of a plugin that is on in the org. */
 const LIVE_INSTALL = ["installing", "installed", "upgrading"];
 /** Every {@link PlatformInboxItem} type, in the order the admin overview lists them. */
@@ -30,14 +25,13 @@ export const PLATFORM_INBOX_TYPES = [
     "permission_confirmation",
     "org_upload_pending",
     "scope_sync_failed",
-    "platform_migration",
     "ownership_transferred",
 ];
 /**
  * The super admin's inbox (plugin scope spec §5.1 rule 5, §13.5): what waits on the platform,
  * gathered from the sources the admin pages read (the 待确认 tab's requests and permission
- * confirmations), plus the scope sync's open failures and the platform components migration's
- * latest run. Stateless, read live from PG.
+ * confirmations), plus the scope sync's open failures and the platform notices. Stateless, read
+ * live from PG.
  */
 let PlatformInboxService = class PlatformInboxService {
     requests;
@@ -49,13 +43,12 @@ let PlatformInboxService = class PlatformInboxService {
         this.kdb = kdb;
     }
     async list() {
-        const [requests, requestCount, pending, failures, failureCount, run, notices, noticeCount] = await Promise.all([
+        const [requests, requestCount, pending, failures, failureCount, notices, noticeCount] = await Promise.all([
             this.requests.listDeployment(),
             this.requests.countPendingDeployment(),
             this.catalog.list({ pending: true }),
             this.scopeSyncFailures(),
             this.countScopeSyncFailures(),
-            this.migrationRun(),
             this.notices(),
             this.countNotices(),
         ]);
@@ -84,16 +77,6 @@ let PlatformInboxService = class PlatformInboxService {
                 createdAt: n.createdAt,
                 notice: n,
             })),
-            ...(run === null
-                ? []
-                : [
-                    {
-                        type: "platform_migration",
-                        id: run.id,
-                        createdAt: run.finishedAt ?? run.startedAt,
-                        run,
-                    },
-                ]),
         ];
         // newest first; equal times by id (a stable order)
         all.sort((a, b) => a.createdAt !== b.createdAt
@@ -111,7 +94,6 @@ let PlatformInboxService = class PlatformInboxService {
             permission_confirmation: pending.length - orgUploads,
             org_upload_pending: orgUploads,
             scope_sync_failed: failureCount,
-            platform_migration: run === null ? 0 : 1,
             ownership_transferred: noticeCount,
         };
         const total = Object.values(byType).reduce((a, b) => a + b, 0);
@@ -123,14 +105,13 @@ let PlatformInboxService = class PlatformInboxService {
      * requests and the failures; the permission confirmations are the catalog's pending list).
      */
     async count() {
-        const [requests, pending, failures, run, notices] = await Promise.all([
+        const [requests, pending, failures, notices] = await Promise.all([
             this.requests.countPendingDeployment(),
             this.catalog.list({ pending: true }),
             this.countScopeSyncFailures(),
-            this.migrationRun(),
             this.countNotices(),
         ]);
-        return requests + pending.length + failures + (run === null ? 0 : 1) + notices;
+        return requests + pending.length + failures + notices;
     }
     async countNotices() {
         const r = await this.kdb.db
@@ -240,36 +221,6 @@ let PlatformInboxService = class PlatformInboxService {
             failedAt: r.failed_at.toISOString(),
         }));
     }
-    /**
-     * The latest migration run when it needs a look (see {@link MigrationRunView}); null when it
-     * finished without failed items, is still running, or there was none. An earlier run's failure
-     * is not shown: each run tries every unwritten item again.
-     */
-    async migrationRun() {
-        const run = await this.kdb.db
-            .selectFrom("platform_migration_runs")
-            .select(["id", "started_at", "finished_at", "stats"])
-            .orderBy("started_at", "desc")
-            .orderBy("id", "desc")
-            .limit(1)
-            .executeTakeFirst();
-        if (run === undefined)
-            return null;
-        const failed = run.stats.itemsFailed;
-        const itemsFailed = Array.isArray(failed)
-            ? failed.filter((x) => typeof x === "string")
-            : [];
-        const stuck = run.finished_at === null && run.started_at.getTime() < Date.now() - MIGRATION_RUN_STUCK_MS;
-        if (!stuck && (run.finished_at === null || itemsFailed.length === 0))
-            return null;
-        return {
-            id: run.id,
-            startedAt: run.started_at.toISOString(),
-            finishedAt: run.finished_at?.toISOString() ?? null,
-            stuck,
-            itemsFailed,
-        };
-    }
 };
 PlatformInboxService = __decorate([
     Injectable(),

package/dist/infra/outbox/outbox.service.d.ts

@@ -46,6 +46,12 @@ export declare class OutboxService {
      * conflicts, else logs an error. Undefined data is stored as JSON null.
      */
     add<T>(job: OutboxJob<T>): Promise<boolean>;
+    /**
+     * {@link add} for many jobs in one multi-row insert per {@link ADD_MANY_CHUNK} jobs (an eval
+     * run's cases). A job whose (queue, jobId) is already owed is skipped without comparing its data.
+     * Returns how many rows it inserted.
+     */
+    addMany<T>(jobs: readonly OutboxJob<T>[]): Promise<number>;
     /** Collects `id` for its transaction; the first id registers the transaction's one hint. */
     private deliverAfterCommit;
 }

package/dist/infra/outbox/outbox.service.js

@@ -21,6 +21,29 @@ export const OUTBOX_FAST_PATH = Symbol("OUTBOX_FAST_PATH");
  * logging an error (spec §4, designer's call: "throws in tests, logs in production").
  */
 export const OUTBOX_STRICT_CONFLICTS = Symbol("OUTBOX_STRICT_CONFLICTS");
+/** Jobs per insert statement of {@link OutboxService.addMany} (6 parameters each). */
+const ADD_MANY_CHUNK = 1000;
+/** The row of `job` (throws on a job id with `:`). */
+function rowOf(job) {
+    if (job.jobId.includes(":")) {
+        throw new Error(`outbox job id "${job.jobId}" must not contain ":" (BullMQ uses it as its key separator); ` +
+            'join the id\'s parts with "-" instead');
+    }
+    return {
+        queue: job.queue,
+        job_name: job.name,
+        job_id: job.jobId,
+        data: JSON.stringify(job.data ?? null),
+        run_at: job.runAt ?? null,
+        org_id: job.orgId ?? null,
+    };
+}
+/**
+ * Only a job due now goes through the fast path (ruling R20): a delayed one (a backstop, a
+ * timeout) is claimed by the relay within its next tick and added with its remaining delay, so the
+ * commit's caller spends no claim transaction on work due in seconds or hours.
+ */
+const dueNow = (job) => job.runAt === undefined || job.runAt.getTime() <= Date.now();
 /**
  * The ids each open transaction inserted, keyed by its transaction store: lives only as long as
  * that transaction (a WeakMap entry, no state shared across requests).
@@ -51,31 +74,16 @@ let OutboxService = class OutboxService {
      * conflicts, else logs an error. Undefined data is stored as JSON null.
      */
     async add(job) {
-        if (job.jobId.includes(":")) {
-            throw new Error(`outbox job id "${job.jobId}" must not contain ":" (BullMQ uses it as its key separator); ` +
-                'join the id\'s parts with "-" instead');
-        }
         const json = JSON.stringify(job.data ?? null);
         const row = await this.db
             .insertInto("outbox")
-            .values({
-            queue: job.queue,
-            job_name: job.name,
-            job_id: job.jobId,
-            data: json,
-            run_at: job.runAt ?? null,
-            org_id: job.orgId ?? null,
-        })
+            .values(rowOf(job))
             .onConflict((oc) => oc.columns(["queue", "job_id"]).where("dead_at", "is", null).doNothing())
             .returning("id")
             .executeTakeFirst();
         if (row) {
-            // only a job due now goes through the fast path (ruling R20): a delayed one (a backstop, a
-            // timeout) is claimed by the relay within its next tick and added with its remaining delay,
-            // so the commit's caller spends no claim transaction on work due in seconds or hours
-            if (job.runAt === undefined || job.runAt.getTime() <= Date.now()) {
+            if (dueNow(job))
                 this.deliverAfterCommit(row.id);
-            }
             return true;
         }
         const stored = await this.db
@@ -100,6 +108,29 @@ let OutboxService = class OutboxService {
         }
         return false;
     }
+    /**
+     * {@link add} for many jobs in one multi-row insert per {@link ADD_MANY_CHUNK} jobs (an eval
+     * run's cases). A job whose (queue, jobId) is already owed is skipped without comparing its data.
+     * Returns how many rows it inserted.
+     */
+    async addMany(jobs) {
+        let inserted = 0;
+        for (let i = 0; i < jobs.length; i += ADD_MANY_CHUNK) {
+            const chunk = jobs.slice(i, i + ADD_MANY_CHUNK);
+            const rows = await this.db
+                .insertInto("outbox")
+                .values(chunk.map(rowOf))
+                .onConflict((oc) => oc.columns(["queue", "job_id"]).where("dead_at", "is", null).doNothing())
+                .returning(["id", "run_at"])
+                .execute();
+            for (const r of rows) {
+                if (dueNow({ runAt: r.run_at ?? undefined }))
+                    this.deliverAfterCommit(r.id);
+            }
+            inserted += rows.length;
+        }
+        return inserted;
+    }
     /** Collects `id` for its transaction; the first id registers the transaction's one hint. */
     deliverAfterCommit(id) {
         // `mandatory` guarantees a live store here
@@ -119,6 +150,9 @@ let OutboxService = class OutboxService {
 __decorate([
     Transactional({ propagation: "mandatory" })
 ], OutboxService.prototype, "add", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], OutboxService.prototype, "addMany", null);
 OutboxService = __decorate([
     Injectable(),
     __param(0, Inject(TransactionHost)),

package/dist/infra/outbox/registry.d.ts

@@ -66,6 +66,37 @@ export declare const OUTBOX_JOBS: {
             readonly removeOnFail: true;
         };
     };
+    readonly "run-stop": {
+        readonly queue: "cap-kernel-maintenance";
+        readonly idempotent: "stopping a finished run is a no-op";
+        readonly processedIn: "packages/kernel/src/runtime/maintenance.ts";
+        readonly opts: {
+            readonly attempts: 5;
+            readonly backoff: {
+                readonly type: "exponential";
+                readonly delay: 5000;
+            };
+            readonly removeOnComplete: true;
+            readonly removeOnFail: {
+                readonly age: number;
+                readonly count: 1000;
+            };
+        };
+    };
+    readonly "sandbox-destroy-for": {
+        readonly queue: "cap-kernel-maintenance";
+        readonly idempotent: "destroying a destroyed device is a no-op";
+        readonly processedIn: "packages/kernel/src/runtime/maintenance.ts";
+        readonly opts: {
+            readonly attempts: 5;
+            readonly backoff: {
+                readonly type: "exponential";
+                readonly delay: 30000;
+            };
+            readonly removeOnComplete: true;
+            readonly removeOnFail: 100;
+        };
+    };
     readonly "deliver-to-parent": {
         readonly queue: "cap-kernel-maintenance";
         readonly idempotent: "the delivery's idempotency key is the child run id";
@@ -114,6 +145,151 @@ export declare const OUTBOX_JOBS: {
             readonly removeOnFail: true;
         };
     };
+    readonly "channel-resume": {
+        readonly queue: "cap-kernel-channels";
+        readonly idempotent: "the catch-up re-reads which of the connection's conversations lag their log and adds their delivery jobs, and a delivery resumes from the delivered seq under a per-conversation lock, so a second catch-up sends nothing twice";
+        readonly processedIn: "packages/kernel/src/channels/channels.module.ts";
+        readonly opts: {
+            readonly attempts: 5;
+            readonly backoff: {
+                readonly type: "exponential";
+                readonly delay: 5000;
+            };
+            readonly priority: 10;
+            readonly removeOnComplete: true;
+            readonly removeOnFail: true;
+        };
+    };
+    readonly "scope-item": {
+        readonly queue: "cap-kernel-plugin-scope";
+        readonly idempotent: "the sync converges each (item, org) from the scope, switches and installs it reads under the org's lock, and the installer re-checks under the org row lock, so a second run changes nothing";
+        readonly processedIn: "packages/kernel/src/catalog/scope-sync-workers.ts";
+        readonly opts: {
+            readonly attempts: 1;
+            readonly removeOnComplete: true;
+            readonly removeOnFail: true;
+        };
+    };
+    readonly "scope-item-backstop": {
+        readonly queue: "cap-kernel-plugin-scope";
+        readonly idempotent: "the sync converges each (item, org) from what it reads, as a scope-item job does, so a run after the immediate job changes nothing";
+        readonly processedIn: "packages/kernel/src/catalog/scope-sync-workers.ts";
+        readonly opts: {
+            readonly attempts: 5;
+            readonly backoff: {
+                readonly type: "exponential";
+                readonly delay: 60000;
+            };
+            readonly removeOnComplete: true;
+            readonly removeOnFail: true;
+        };
+    };
+    readonly "scope-org": {
+        readonly queue: "cap-kernel-plugin-scope";
+        readonly idempotent: "the sync converges each (item, org) of the org from what it reads, so a second run changes nothing";
+        readonly processedIn: "packages/kernel/src/catalog/scope-sync-workers.ts";
+        readonly opts: {
+            readonly attempts: 1;
+            readonly removeOnComplete: true;
+            readonly removeOnFail: true;
+        };
+    };
+    readonly "owned-plugin-cleanup": {
+        readonly queue: "cap-kernel-maintenance";
+        readonly idempotent: "the cleanup takes the extension out only while no live item uses it, and a missing install or a released claim changes nothing";
+        readonly processedIn: "packages/kernel/src/runtime/maintenance.ts";
+        readonly opts: {
+            readonly attempts: 3;
+            readonly backoff: {
+                readonly type: "exponential";
+                readonly delay: 5000;
+            };
+            readonly removeOnComplete: true;
+            readonly removeOnFail: true;
+        };
+    };
+    readonly "sched-fire": {
+        readonly queue: "cap-kernel-maintenance";
+        readonly idempotent: "a fire acts only on a pending task run, under its row lock; a retried start reuses what the first one made";
+        readonly processedIn: "packages/kernel/src/runtime/maintenance.ts";
+        readonly opts: {
+            readonly attempts: 3;
+            readonly backoff: {
+                readonly type: "exponential";
+                readonly delay: 2000;
+            };
+            readonly removeOnComplete: true;
+            readonly removeOnFail: true;
+        };
+    };
+    readonly "sched-settle": {
+        readonly queue: "cap-kernel-maintenance";
+        readonly idempotent: "a check acts only on a task run still pending (claimed for the claimed check, unclaimed for the unfired one), under the task and run row locks, so a run claimed, started, ended or skipped since is left as it is";
+        readonly processedIn: "packages/kernel/src/runtime/maintenance.ts";
+        readonly opts: {
+            readonly attempts: 5;
+            readonly backoff: {
+                readonly type: "exponential";
+                readonly delay: 5000;
+            };
+            readonly removeOnComplete: true;
+            readonly removeOnFail: true;
+        };
+    };
+    readonly "device-op-resolve": {
+        readonly queue: "cap-kernel-maintenance";
+        readonly idempotent: "resolving an op whose entry is gone is a no-op (the entry is read under the machine row's lock, and under the network ask's lock for an op that answers one, so the ask is decided at most once); the resolver only reads the device, never sends a change";
+        readonly processedIn: "packages/kernel/src/runtime/maintenance.ts";
+        readonly opts: {
+            readonly attempts: 5;
+            readonly backoff: {
+                readonly type: "exponential";
+                readonly delay: 5000;
+            };
+            readonly removeOnComplete: true;
+            readonly removeOnFail: true;
+        };
+    };
+    readonly "bg-wake": {
+        readonly queue: "cap-kernel-maintenance";
+        readonly idempotent: "the wake only calls ensureRun, which decides from the conversation's state under its row lock, so a wake with nothing unconsumed or an active run starts nothing";
+        readonly processedIn: "packages/kernel/src/runtime/maintenance.ts";
+        readonly opts: {
+            readonly removeOnComplete: true;
+            readonly removeOnFail: true;
+        };
+    };
+    readonly "eval-case": {
+        readonly queue: "cap-kernel-evals";
+        readonly idempotent: "a case job replays only the case's unfinished results (and pending judgements) of a still-active run, each under a fresh claim, so a second job writes no result twice";
+        readonly processedIn: "packages/kernel/src/evals/evals.module.ts";
+        readonly opts: {
+            readonly attempts: 3;
+            readonly backoff: {
+                readonly type: "exponential";
+                readonly delay: 1000;
+            };
+            readonly removeOnComplete: true;
+            readonly removeOnFail: 1000;
+        };
+    };
+    readonly lifecycle: {
+        readonly queue: "cap-kernel-lifecycle";
+        readonly idempotent: "lifecycle handlers must be idempotent (the SDK contract): they delete what the plugin holds for the removed member, agent or org, and deleting it again is a no-op";
+        readonly processedIn: "packages/kernel/src/extensions/lifecycle-hooks.ts";
+        readonly opts: {
+            readonly attempts: 15;
+            readonly backoff: {
+                readonly type: "exponential";
+                readonly delay: 2000;
+            };
+            readonly removeOnComplete: true;
+            readonly removeOnFail: {
+                readonly age: number;
+                readonly count: 1000;
+            };
+        };
+    };
 };
 export type OutboxJobName = keyof typeof OUTBOX_JOBS;
 /** The registry's BullMQ options of a job name (none for a name it does not list). */