@shipfox/api-runners 4.0.0 → 6.0.0

package/dist/db/schema/runner-control-sessions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/runner-control-sessions.ts"],"sourcesContent":["import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport {pgTable} from './common.js';\n\nexport const runnerBootstrapTokens = pgTable(\n  'runner_bootstrap_tokens',\n  {\n    id: uuidv7PrimaryKey(),\n    runnerInstanceId: uuid('runner_instance_id').notNull(),\n    provisionerId: uuid('provisioner_id').notNull(),\n    hashedToken: text('hashed_token').notNull(),\n    prefix: text('prefix').notNull(),\n    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),\n    consumedAt: timestamp('consumed_at', {withTimezone: true}),\n    revokedAt: timestamp('revoked_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('runners_runner_bootstrap_tokens_hashed_token_unique').on(table.hashedToken),\n    index('runners_runner_bootstrap_tokens_runner_instance_idx').on(table.runnerInstanceId),\n  ],\n);\n\nexport const runnerControlSessions = pgTable(\n  'runner_control_sessions',\n  {\n    id: uuidv7PrimaryKey(),\n    runnerInstanceId: uuid('runner_instance_id').notNull(),\n    provisionerId: uuid('provisioner_id').notNull(),\n    hashedToken: text('hashed_token').notNull(),\n    prefix: text('prefix').notNull(),\n    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),\n    lastSeenAt: timestamp('last_seen_at', {withTimezone: true}).notNull().defaultNow(),\n    closedAt: timestamp('closed_at', {withTimezone: true}),\n    closeReason: text('close_reason'),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('runners_runner_control_sessions_hashed_token_unique').on(table.hashedToken),\n    uniqueIndex('runners_runner_control_sessions_active_runner_instance_unique')\n      .on(table.runnerInstanceId)\n      .where(sql`\"closed_at\" is null`),\n    index('runners_runner_control_sessions_runner_instance_idx').on(table.runnerInstanceId),\n  ],\n);\n"],"names":["uuidv7PrimaryKey","sql","index","text","timestamp","uniqueIndex","uuid","pgTable","runnerBootstrapTokens","id","runnerInstanceId","notNull","provisionerId","hashedToken","prefix","expiresAt","withTimezone","consumedAt","revokedAt","createdAt","defaultNow","table","on","runnerControlSessions","lastSeenAt","closedAt","closeReason","where"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,wBAAwB;AACvD,SAAQC,GAAG,QAAO,cAAc;AAChC,SAAQC,KAAK,EAAEC,IAAI,EAAEC,SAAS,EAAEC,WAAW,EAAEC,IAAI,QAAO,sBAAsB;AAC9E,SAAQC,OAAO,QAAO,cAAc;AAEpC,OAAO,MAAMC,wBAAwBD,QACnC,2BACA;IACEE,IAAIT;IACJU,kBAAkBJ,KAAK,sBAAsBK,OAAO;IACpDC,eAAeN,KAAK,kBAAkBK,OAAO;IAC7CE,aAAaV,KAAK,gBAAgBQ,OAAO;IACzCG,QAAQX,KAAK,UAAUQ,OAAO;IAC9BI,WAAWX,UAAU,cAAc;QAACY,cAAc;IAAI,GAAGL,OAAO;IAChEM,YAAYb,UAAU,eAAe;QAACY,cAAc;IAAI;IACxDE,WAAWd,UAAU,cAAc;QAACY,cAAc;IAAI;IACtDG,WAAWf,UAAU,cAAc;QAACY,cAAc;IAAI,GAAGL,OAAO,GAAGS,UAAU;AAC/E,GACA,CAACC,QAAU;QACThB,YAAY,uDAAuDiB,EAAE,CAACD,MAAMR,WAAW;QACvFX,MAAM,uDAAuDoB,EAAE,CAACD,MAAMX,gBAAgB;KACvF,EACD;AAEF,OAAO,MAAMa,wBAAwBhB,QACnC,2BACA;IACEE,IAAIT;IACJU,kBAAkBJ,KAAK,sBAAsBK,OAAO;IACpDC,eAAeN,KAAK,kBAAkBK,OAAO;IAC7CE,aAAaV,KAAK,gBAAgBQ,OAAO;IACzCG,QAAQX,KAAK,UAAUQ,OAAO;IAC9BI,WAAWX,UAAU,cAAc;QAACY,cAAc;IAAI,GAAGL,OAAO;IAChEa,YAAYpB,UAAU,gBAAgB;QAACY,cAAc;IAAI,GAAGL,OAAO,GAAGS,UAAU;IAChFK,UAAUrB,UAAU,aAAa;QAACY,cAAc;IAAI;IACpDU,aAAavB,KAAK;IAClBgB,WAAWf,UAAU,cAAc;QAACY,cAAc;IAAI,GAAGL,OAAO,GAAGS,UAAU;AAC/E,GACA,CAACC,QAAU;QACThB,YAAY,uDAAuDiB,EAAE,CAACD,MAAMR,WAAW;QACvFR,YAAY,iEACTiB,EAAE,CAACD,MAAMX,gBAAgB,EACzBiB,KAAK,CAAC1B,GAAG,CAAC,mBAAmB,CAAC;QACjCC,MAAM,uDAAuDoB,EAAE,CAACD,MAAMX,gBAAgB;KACvF,EACD"}

package/dist/db/schema/{provisioned-runners.d.ts → runner-instances.d.ts}

@@ -1,12 +1,12 @@
-import type { ProvisionedRunner } from '#core/entities/provisioned-runner.js';
-export declare const provisionedRunnerStateEnum: import("drizzle-orm/pg-core").PgEnum<["starting", "running", "stopping", "stopped", "failed", "terminated"]>;
-export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWithColumns<{
-    name: "provisioned_runners";
+import type { RunnerInstance } from '#core/entities/runner-instance.js';
+export declare const providerRunnerStateEnum: import("drizzle-orm/pg-core").PgEnum<["starting", "running", "stopping", "stopped", "failed", "terminated"]>;
+export declare const providerRunners: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "runner_instances";
     schema: undefined;
     columns: {
         id: import("drizzle-orm/pg-core").PgColumn<{
             name: "id";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "string";
             columnType: "PgUUID";
             data: string;
@@ -23,12 +23,12 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         workspaceId: import("drizzle-orm/pg-core").PgColumn<{
             name: "workspace_id";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "string";
             columnType: "PgUUID";
             data: string;
             driverParam: string;
-            notNull: true;
+            notNull: false;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
@@ -40,7 +40,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         provisionerId: import("drizzle-orm/pg-core").PgColumn<{
             name: "provisioner_id";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "string";
             columnType: "PgUUID";
             data: string;
@@ -55,14 +55,14 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        provisionedRunnerId: import("drizzle-orm/pg-core").PgColumn<{
-            name: "provisioned_runner_id";
-            tableName: "provisioned_runners";
+        providerRunnerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider_runner_id";
+            tableName: "runner_instances";
             dataType: "string";
             columnType: "PgText";
             data: string;
             driverParam: string;
-            notNull: true;
+            notNull: false;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
@@ -74,7 +74,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         reservationId: import("drizzle-orm/pg-core").PgColumn<{
             name: "reservation_id";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "string";
             columnType: "PgUUID";
             data: string;
@@ -91,7 +91,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         templateKey: import("drizzle-orm/pg-core").PgColumn<{
             name: "template_key";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -108,20 +108,20 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         labels: import("drizzle-orm/pg-core").PgColumn<{
             name: "labels";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "array";
             columnType: "PgArray";
             data: string[];
             driverParam: string | string[];
             notNull: true;
-            hasDefault: false;
+            hasDefault: true;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: import("drizzle-orm").Column<{
                 name: "labels";
-                tableName: "provisioned_runners";
+                tableName: "runner_instances";
                 dataType: "string";
                 columnType: "PgText";
                 data: string;
@@ -151,7 +151,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }>;
         state: import("drizzle-orm/pg-core").PgColumn<{
             name: "state";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "string";
             columnType: "PgEnumColumn";
             data: "starting" | "running" | "stopping" | "stopped" | "failed" | "terminated";
@@ -168,7 +168,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         reason: import("drizzle-orm/pg-core").PgColumn<{
             name: "reason";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -185,7 +185,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         runnerSessionId: import("drizzle-orm/pg-core").PgColumn<{
             name: "runner_session_id";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "string";
             columnType: "PgUUID";
             data: string;
@@ -202,7 +202,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         providerKind: import("drizzle-orm/pg-core").PgColumn<{
             name: "provider_kind";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "string";
             columnType: "PgText";
             data: string;
@@ -217,9 +217,63 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        protocolVersion: import("drizzle-orm/pg-core").PgColumn<{
+            name: "protocol_version";
+            tableName: "runner_instances";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        capabilities: import("drizzle-orm/pg-core").PgColumn<{
+            name: "capabilities";
+            tableName: "runner_instances";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: {
+                harnesses: {
+                    pi?: {
+                        tools: string[];
+                    } | undefined;
+                    claude?: {
+                        tools: string[];
+                    } | undefined;
+                };
+            } | null;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: {
+                harnesses: {
+                    pi?: {
+                        tools: string[];
+                    } | undefined;
+                    claude?: {
+                        tools: string[];
+                    } | undefined;
+                };
+            } | null;
+        }>;
         reportedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "reported_at";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -236,7 +290,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         startedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "started_at";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -253,7 +307,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         stoppingAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "stopping_at";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -270,7 +324,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         stoppedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "stopped_at";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -287,7 +341,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         failedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "failed_at";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -304,7 +358,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         terminatedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "terminated_at";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -321,7 +375,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         reservationReleasedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "reservation_released_at";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -338,7 +392,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         createdAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "created_at";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -355,7 +409,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
         }, {}, {}>;
         updatedAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "updated_at";
-            tableName: "provisioned_runners";
+            tableName: "runner_instances";
             dataType: "date";
             columnType: "PgTimestamp";
             data: Date;
@@ -373,7 +427,7 @@ export declare const provisionedRunners: import("drizzle-orm/pg-core").PgTableWi
     };
     dialect: "pg";
 }>;
-export type ProvisionedRunnerDb = typeof provisionedRunners.$inferSelect;
-export type ProvisionedRunnerInsertDb = typeof provisionedRunners.$inferInsert;
-export declare function toProvisionedRunner(row: ProvisionedRunnerDb): ProvisionedRunner;
-//# sourceMappingURL=provisioned-runners.d.ts.map
+export type RunnerInstanceDb = typeof providerRunners.$inferSelect;
+export type RunnerInstanceInsertDb = typeof providerRunners.$inferInsert;
+export declare function toRunnerInstance(row: RunnerInstanceDb): RunnerInstance;
+//# sourceMappingURL=runner-instances.d.ts.map

package/dist/db/schema/runner-instances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-instances.d.ts","sourceRoot":"","sources":["../../../src/db/schema/runner-instances.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,mCAAmC,CAAC;AAGtE,eAAO,MAAM,uBAAuB,8GAOlC,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0C3B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC;AACnE,MAAM,MAAM,sBAAsB,GAAG,OAAO,eAAe,CAAC,YAAY,CAAC;AAEzE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,gBAAgB,GAAG,cAAc,CAwBtE"}

package/dist/db/schema/{provisioned-runners.js → runner-instances.js}

@@ -1,8 +1,8 @@
 import { uuidv7PrimaryKey } from '@shipfox/node-drizzle';
 import { sql } from 'drizzle-orm';
-import { index, pgEnum, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
+import { index, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid } from 'drizzle-orm/pg-core';
 import { pgTable } from './common.js';
-export const provisionedRunnerStateEnum = pgEnum('runners_provisioned_runner_state', [
+export const providerRunnerStateEnum = pgEnum('runners_provider_runner_state', [
     'starting',
     'running',
     'stopping',
@@ -10,18 +10,22 @@ export const provisionedRunnerStateEnum = pgEnum('runners_provisioned_runner_sta
     'failed',
     'terminated'
 ]);
-export const provisionedRunners = pgTable('provisioned_runners', {
+export const providerRunners = pgTable('runner_instances', {
     id: uuidv7PrimaryKey(),
-    workspaceId: uuid('workspace_id').notNull(),
+    // Kept during the protocol migration for legacy workspace capacity. New capacity is owned
+    // only by its provisioner and has no workspace assignment.
+    workspaceId: uuid('workspace_id'),
     provisionerId: uuid('provisioner_id').notNull(),
-    provisionedRunnerId: text('provisioned_runner_id').notNull(),
+    providerRunnerId: text('provider_runner_id'),
     reservationId: uuid('reservation_id'),
     templateKey: text('template_key'),
-    labels: text('labels').array().notNull(),
-    state: provisionedRunnerStateEnum('state').notNull(),
+    labels: text('labels').array().notNull().default([]),
+    state: providerRunnerStateEnum('state').notNull(),
     reason: text('reason'),
     runnerSessionId: uuid('runner_session_id'),
     providerKind: text('provider_kind'),
+    protocolVersion: text('protocol_version'),
+    capabilities: jsonb('capabilities').$type(),
     reportedAt: timestamp('reported_at', {
         withTimezone: true
     }).notNull(),
@@ -50,17 +54,18 @@ export const provisionedRunners = pgTable('provisioned_runners', {
         withTimezone: true
     }).notNull().defaultNow()
 }, (table)=>[
-        uniqueIndex('runners_provisioned_runners_workspace_provisioner_runner_unique').on(table.workspaceId, table.provisionerId, table.provisionedRunnerId),
-        index('runners_provisioned_runners_workspace_state_updated_idx').on(table.workspaceId, table.state, table.updatedAt),
-        index('runners_provisioned_runners_stale_reaper_idx').on(table.state, table.updatedAt, table.reportedAt, table.workspaceId),
-        index('runners_provisioned_runners_active_template_counts_idx').on(table.workspaceId, table.provisionerId, table.state, table.templateKey).where(sql`"state" in ('starting', 'running') and "template_key" is not null`)
+        uniqueIndex('runners_runner_instances_provisioner_runner_unique').on(table.provisionerId, table.providerRunnerId).where(sql`${table.providerRunnerId} is not null`),
+        index('runners_runner_instances_workspace_state_updated_idx').on(table.state, table.updatedAt),
+        index('runners_runner_instances_stale_reaper_idx').on(table.state, table.updatedAt, table.reportedAt),
+        index('runners_runner_instances_active_template_counts_idx').on(table.provisionerId, table.state, table.templateKey).where(sql`"state" in ('starting', 'running') and "template_key" is not null`)
     ]);
-export function toProvisionedRunner(row) {
+export function toRunnerInstance(row) {
+    if (!row.providerRunnerId) throw new Error('Planned capacity has no provider runner identity');
     return {
         id: row.id,
         workspaceId: row.workspaceId,
         provisionerId: row.provisionerId,
-        provisionedRunnerId: row.provisionedRunnerId,
+        providerRunnerId: row.providerRunnerId,
         reservationId: row.reservationId,
         templateKey: row.templateKey,
         labels: row.labels,
@@ -80,4 +85,4 @@ export function toProvisionedRunner(row) {
     };
 }
 
-//# sourceMappingURL=provisioned-runners.js.map
+//# sourceMappingURL=runner-instances.js.map

package/dist/db/schema/runner-instances.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/db/schema/runner-instances.ts"],"sourcesContent":["import type {RunnerToolCapabilitiesDto} from '@shipfox/api-runners-dto';\nimport {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {index, jsonb, pgEnum, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';\nimport type {RunnerInstance} from '#core/entities/runner-instance.js';\nimport {pgTable} from './common.js';\n\nexport const providerRunnerStateEnum = pgEnum('runners_provider_runner_state', [\n  'starting',\n  'running',\n  'stopping',\n  'stopped',\n  'failed',\n  'terminated',\n]);\n\nexport const providerRunners = pgTable(\n  'runner_instances',\n  {\n    id: uuidv7PrimaryKey(),\n    // Kept during the protocol migration for legacy workspace capacity. New capacity is owned\n    // only by its provisioner and has no workspace assignment.\n    workspaceId: uuid('workspace_id'),\n    provisionerId: uuid('provisioner_id').notNull(),\n    providerRunnerId: text('provider_runner_id'),\n    reservationId: uuid('reservation_id'),\n    templateKey: text('template_key'),\n    labels: text('labels').array().notNull().default([]),\n    state: providerRunnerStateEnum('state').notNull(),\n    reason: text('reason'),\n    runnerSessionId: uuid('runner_session_id'),\n    providerKind: text('provider_kind'),\n    protocolVersion: text('protocol_version'),\n    capabilities: jsonb('capabilities').$type<RunnerToolCapabilitiesDto | null>(),\n    reportedAt: timestamp('reported_at', {withTimezone: true}).notNull(),\n    startedAt: timestamp('started_at', {withTimezone: true}),\n    stoppingAt: timestamp('stopping_at', {withTimezone: true}),\n    stoppedAt: timestamp('stopped_at', {withTimezone: true}),\n    failedAt: timestamp('failed_at', {withTimezone: true}),\n    terminatedAt: timestamp('terminated_at', {withTimezone: true}),\n    reservationReleasedAt: timestamp('reservation_released_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    uniqueIndex('runners_runner_instances_provisioner_runner_unique')\n      .on(table.provisionerId, table.providerRunnerId)\n      .where(sql`${table.providerRunnerId} is not null`),\n    index('runners_runner_instances_workspace_state_updated_idx').on(table.state, table.updatedAt),\n    index('runners_runner_instances_stale_reaper_idx').on(\n      table.state,\n      table.updatedAt,\n      table.reportedAt,\n    ),\n    index('runners_runner_instances_active_template_counts_idx')\n      .on(table.provisionerId, table.state, table.templateKey)\n      .where(sql`\"state\" in ('starting', 'running') and \"template_key\" is not null`),\n  ],\n);\n\nexport type RunnerInstanceDb = typeof providerRunners.$inferSelect;\nexport type RunnerInstanceInsertDb = typeof providerRunners.$inferInsert;\n\nexport function toRunnerInstance(row: RunnerInstanceDb): RunnerInstance {\n  if (!row.providerRunnerId) throw new Error('Planned capacity has no provider runner identity');\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    provisionerId: row.provisionerId,\n    providerRunnerId: row.providerRunnerId,\n    reservationId: row.reservationId,\n    templateKey: row.templateKey,\n    labels: row.labels,\n    state: row.state,\n    reason: row.reason,\n    runnerSessionId: row.runnerSessionId,\n    providerKind: row.providerKind,\n    reportedAt: row.reportedAt,\n    startedAt: row.startedAt,\n    stoppingAt: row.stoppingAt,\n    stoppedAt: row.stoppedAt,\n    failedAt: row.failedAt,\n    terminatedAt: row.terminatedAt,\n    reservationReleasedAt: row.reservationReleasedAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","index","jsonb","pgEnum","text","timestamp","uniqueIndex","uuid","pgTable","providerRunnerStateEnum","providerRunners","id","workspaceId","provisionerId","notNull","providerRunnerId","reservationId","templateKey","labels","array","default","state","reason","runnerSessionId","providerKind","protocolVersion","capabilities","$type","reportedAt","withTimezone","startedAt","stoppingAt","stoppedAt","failedAt","terminatedAt","reservationReleasedAt","createdAt","defaultNow","updatedAt","table","on","where","toRunnerInstance","row","Error"],"mappings":"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"}

package/dist/db/schema/runner-sessions.d.ts

@@ -1,6 +1,6 @@
 import type { RunnerSession } from '#core/entities/runner-session.js';
 export declare const runnerSessionScopeEnum: import("drizzle-orm/pg-core").PgEnum<["workspace"]>;
-export declare const runnerSessionRegistrationTokenKindEnum: import("drizzle-orm/pg-core").PgEnum<["manual", "ephemeral"]>;
+export declare const runnerSessionRegistrationTokenKindEnum: import("drizzle-orm/pg-core").PgEnum<["manual", "ephemeral", "activation"]>;
 export declare const runnerSessions: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "runner_sessions";
     schema: undefined;
@@ -78,14 +78,31 @@ export declare const runnerSessions: import("drizzle-orm/pg-core").PgTableWithCo
             tableName: "runner_sessions";
             dataType: "string";
             columnType: "PgEnumColumn";
-            data: "manual" | "ephemeral";
+            data: "manual" | "ephemeral" | "activation";
             driverParam: string;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: ["manual", "ephemeral"];
+            enumValues: ["manual", "ephemeral", "activation"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        runnerInstanceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "runner_instance_id";
+            tableName: "runner_sessions";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
             baseColumn: never;
             identity: undefined;
             generated: undefined;
@@ -107,8 +124,8 @@ export declare const runnerSessions: import("drizzle-orm/pg-core").PgTableWithCo
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        provisionedRunnerId: import("drizzle-orm/pg-core").PgColumn<{
-            name: "provisioned_runner_id";
+        providerRunnerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider_runner_id";
             tableName: "runner_sessions";
             dataType: "string";
             columnType: "PgText";
@@ -255,6 +272,23 @@ export declare const runnerSessions: import("drizzle-orm/pg-core").PgTableWithCo
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        revokedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "revoked_at";
+            tableName: "runner_sessions";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         createdAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "created_at";
             tableName: "runner_sessions";

package/dist/db/schema/runner-sessions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner-sessions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/runner-sessions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AAGpE,eAAO,MAAM,sBAAsB,qDAAwD,CAAC;AAC5F,eAAO,MAAM,sCAAsC,+DAGlD,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqC1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AACjE,MAAM,MAAM,qBAAqB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAEvE,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa,CAqBnE"}
+{"version":3,"file":"runner-sessions.d.ts","sourceRoot":"","sources":["../../../src/db/schema/runner-sessions.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,kCAAkC,CAAC;AAGpE,eAAO,MAAM,sBAAsB,qDAAwD,CAAC;AAC5F,eAAO,MAAM,sCAAsC,6EAGlD,CAAC;AAEF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuC1B,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AACjE,MAAM,MAAM,qBAAqB,GAAG,OAAO,cAAc,CAAC,YAAY,CAAC;AAEvE,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,aAAa,CAuBnE"}

package/dist/db/schema/runner-sessions.js

@@ -7,7 +7,8 @@ export const runnerSessionScopeEnum = pgEnum('runners_runner_session_scope', [
 ]);
 export const runnerSessionRegistrationTokenKindEnum = pgEnum('runners_runner_session_registration_token_kind', [
     'manual',
-    'ephemeral'
+    'ephemeral',
+    'activation'
 ]);
 export const runnerSessions = pgTable('runner_sessions', {
     id: uuidv7PrimaryKey(),
@@ -15,8 +16,9 @@ export const runnerSessions = pgTable('runner_sessions', {
     scope: runnerSessionScopeEnum('scope').notNull().default('workspace'),
     registrationTokenId: uuid('registration_token_id').notNull(),
     registrationTokenKind: runnerSessionRegistrationTokenKindEnum('registration_token_kind').notNull(),
+    runnerInstanceId: uuid('runner_instance_id'),
     provisionerId: uuid('provisioner_id'),
-    provisionedRunnerId: text('provisioned_runner_id'),
+    providerRunnerId: text('provider_runner_id'),
     labels: text('labels').array().notNull(),
     toolCapabilities: jsonb('tool_capabilities').$type(),
     toolCapabilitiesReportedAt: timestamp('tool_capabilities_reported_at', {
@@ -24,6 +26,9 @@ export const runnerSessions = pgTable('runner_sessions', {
     }),
     maxClaims: integer('max_claims'),
     claimsUsed: integer('claims_used').notNull().default(0),
+    revokedAt: timestamp('revoked_at', {
+        withTimezone: true
+    }),
     createdAt: timestamp('created_at', {
         withTimezone: true
     }).notNull().defaultNow(),
@@ -32,9 +37,9 @@ export const runnerSessions = pgTable('runner_sessions', {
     }).notNull().defaultNow()
 }, (table)=>[
         index('runners_runner_sessions_kind_created_id_idx').on(table.registrationTokenKind, table.createdAt, table.id),
-        check('runners_runner_sessions_claims_ck', sql`${table.claimsUsed} >= 0 AND ((${table.registrationTokenKind} = 'manual' AND ${table.maxClaims} IS NULL) OR (${table.registrationTokenKind} = 'ephemeral' AND ${table.maxClaims} IS NOT NULL AND ${table.maxClaims} > 0 AND ${table.claimsUsed} <= ${table.maxClaims}))`),
-        check('runners_runner_sessions_link_ck', sql`((${table.registrationTokenKind} = 'manual' AND ${table.provisionerId} IS NULL AND ${table.provisionedRunnerId} IS NULL) OR (${table.registrationTokenKind} = 'ephemeral' AND ${table.provisionerId} IS NOT NULL AND ${table.provisionedRunnerId} IS NOT NULL))`),
-        index('runners_runner_sessions_provisioned_runner_updated_idx').on(table.workspaceId, table.provisionerId, table.provisionedRunnerId, table.updatedAt).where(sql`"provisioner_id" IS NOT NULL`)
+        check('runners_runner_sessions_claims_ck', sql`${table.claimsUsed} >= 0 AND ((${table.registrationTokenKind} = 'manual' AND ${table.maxClaims} IS NULL) OR (${table.registrationTokenKind} in ('ephemeral', 'activation') AND ${table.maxClaims} IS NOT NULL AND ${table.maxClaims} > 0 AND ${table.claimsUsed} <= ${table.maxClaims}))`),
+        check('runners_runner_sessions_link_ck', sql`((${table.registrationTokenKind} = 'manual' AND ${table.runnerInstanceId} IS NULL AND ${table.provisionerId} IS NULL AND ${table.providerRunnerId} IS NULL) OR (${table.registrationTokenKind} = 'ephemeral' AND ${table.runnerInstanceId} IS NULL AND ${table.provisionerId} IS NOT NULL AND ${table.providerRunnerId} IS NOT NULL) OR (${table.registrationTokenKind} = 'activation' AND ${table.runnerInstanceId} IS NOT NULL AND ${table.provisionerId} IS NOT NULL AND ${table.providerRunnerId} IS NOT NULL))`),
+        index('runners_runner_sessions_provider_runner_updated_idx').on(table.workspaceId, table.provisionerId, table.providerRunnerId, table.updatedAt).where(sql`"provisioner_id" IS NOT NULL`)
     ]);
 export function toRunnerSession(row) {
     if (row.scope !== 'workspace') {
@@ -46,13 +51,15 @@ export function toRunnerSession(row) {
         scope: row.scope,
         registrationTokenId: row.registrationTokenId,
         registrationTokenKind: row.registrationTokenKind,
+        runnerInstanceId: row.runnerInstanceId,
         provisionerId: row.provisionerId,
-        provisionedRunnerId: row.provisionedRunnerId,
+        providerRunnerId: row.providerRunnerId,
         labels: row.labels,
         toolCapabilities: row.toolCapabilities,
         toolCapabilitiesReportedAt: row.toolCapabilitiesReportedAt,
         maxClaims: row.maxClaims,
         claimsUsed: row.claimsUsed,
+        revokedAt: row.revokedAt,
         createdAt: row.createdAt,
         updatedAt: row.updatedAt
     };

package/dist/db/schema/runner-sessions.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/db/schema/runner-sessions.ts"],"sourcesContent":["import type {RunnerToolCapabilitiesDto} from '@shipfox/api-runners-dto';\nimport {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {check, index, integer, jsonb, pgEnum, text, timestamp, uuid} from 'drizzle-orm/pg-core';\nimport type {RunnerSession} from '#core/entities/runner-session.js';\nimport {pgTable} from './common.js';\n\nexport const runnerSessionScopeEnum = pgEnum('runners_runner_session_scope', ['workspace']);\nexport const runnerSessionRegistrationTokenKindEnum = pgEnum(\n  'runners_runner_session_registration_token_kind',\n  ['manual', 'ephemeral'],\n);\n\nexport const runnerSessions = pgTable(\n  'runner_sessions',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    scope: runnerSessionScopeEnum('scope').notNull().default('workspace'),\n    registrationTokenId: uuid('registration_token_id').notNull(),\n    registrationTokenKind:\n      runnerSessionRegistrationTokenKindEnum('registration_token_kind').notNull(),\n    provisionerId: uuid('provisioner_id'),\n    provisionedRunnerId: text('provisioned_runner_id'),\n    labels: text('labels').array().notNull(),\n    toolCapabilities: jsonb('tool_capabilities').$type<RunnerToolCapabilitiesDto | null>(),\n    toolCapabilitiesReportedAt: timestamp('tool_capabilities_reported_at', {withTimezone: true}),\n    maxClaims: integer('max_claims'),\n    claimsUsed: integer('claims_used').notNull().default(0),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    index('runners_runner_sessions_kind_created_id_idx').on(\n      table.registrationTokenKind,\n      table.createdAt,\n      table.id,\n    ),\n    check(\n      'runners_runner_sessions_claims_ck',\n      sql`${table.claimsUsed} >= 0 AND ((${table.registrationTokenKind} = 'manual' AND ${table.maxClaims} IS NULL) OR (${table.registrationTokenKind} = 'ephemeral' AND ${table.maxClaims} IS NOT NULL AND ${table.maxClaims} > 0 AND ${table.claimsUsed} <= ${table.maxClaims}))`,\n    ),\n    check(\n      'runners_runner_sessions_link_ck',\n      sql`((${table.registrationTokenKind} = 'manual' AND ${table.provisionerId} IS NULL AND ${table.provisionedRunnerId} IS NULL) OR (${table.registrationTokenKind} = 'ephemeral' AND ${table.provisionerId} IS NOT NULL AND ${table.provisionedRunnerId} IS NOT NULL))`,\n    ),\n    index('runners_runner_sessions_provisioned_runner_updated_idx')\n      .on(table.workspaceId, table.provisionerId, table.provisionedRunnerId, table.updatedAt)\n      .where(sql`\"provisioner_id\" IS NOT NULL`),\n  ],\n);\n\nexport type RunnerSessionDb = typeof runnerSessions.$inferSelect;\nexport type RunnerSessionInsertDb = typeof runnerSessions.$inferInsert;\n\nexport function toRunnerSession(row: RunnerSessionDb): RunnerSession {\n  if (row.scope !== 'workspace') {\n    throw new Error(`Unexpected runner session scope: ${row.scope}`);\n  }\n\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    scope: row.scope,\n    registrationTokenId: row.registrationTokenId,\n    registrationTokenKind: row.registrationTokenKind,\n    provisionerId: row.provisionerId,\n    provisionedRunnerId: row.provisionedRunnerId,\n    labels: row.labels,\n    toolCapabilities: row.toolCapabilities,\n    toolCapabilitiesReportedAt: row.toolCapabilitiesReportedAt,\n    maxClaims: row.maxClaims,\n    claimsUsed: row.claimsUsed,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","check","index","integer","jsonb","pgEnum","text","timestamp","uuid","pgTable","runnerSessionScopeEnum","runnerSessionRegistrationTokenKindEnum","runnerSessions","id","workspaceId","notNull","scope","default","registrationTokenId","registrationTokenKind","provisionerId","provisionedRunnerId","labels","array","toolCapabilities","$type","toolCapabilitiesReportedAt","withTimezone","maxClaims","claimsUsed","createdAt","defaultNow","updatedAt","table","on","where","toRunnerSession","row","Error"],"mappings":"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"}
+{"version":3,"sources":["../../../src/db/schema/runner-sessions.ts"],"sourcesContent":["import type {RunnerToolCapabilitiesDto} from '@shipfox/api-runners-dto';\nimport {uuidv7PrimaryKey} from '@shipfox/node-drizzle';\nimport {sql} from 'drizzle-orm';\nimport {check, index, integer, jsonb, pgEnum, text, timestamp, uuid} from 'drizzle-orm/pg-core';\nimport type {RunnerSession} from '#core/entities/runner-session.js';\nimport {pgTable} from './common.js';\n\nexport const runnerSessionScopeEnum = pgEnum('runners_runner_session_scope', ['workspace']);\nexport const runnerSessionRegistrationTokenKindEnum = pgEnum(\n  'runners_runner_session_registration_token_kind',\n  ['manual', 'ephemeral', 'activation'],\n);\n\nexport const runnerSessions = pgTable(\n  'runner_sessions',\n  {\n    id: uuidv7PrimaryKey(),\n    workspaceId: uuid('workspace_id').notNull(),\n    scope: runnerSessionScopeEnum('scope').notNull().default('workspace'),\n    registrationTokenId: uuid('registration_token_id').notNull(),\n    registrationTokenKind:\n      runnerSessionRegistrationTokenKindEnum('registration_token_kind').notNull(),\n    runnerInstanceId: uuid('runner_instance_id'),\n    provisionerId: uuid('provisioner_id'),\n    providerRunnerId: text('provider_runner_id'),\n    labels: text('labels').array().notNull(),\n    toolCapabilities: jsonb('tool_capabilities').$type<RunnerToolCapabilitiesDto | null>(),\n    toolCapabilitiesReportedAt: timestamp('tool_capabilities_reported_at', {withTimezone: true}),\n    maxClaims: integer('max_claims'),\n    claimsUsed: integer('claims_used').notNull().default(0),\n    revokedAt: timestamp('revoked_at', {withTimezone: true}),\n    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),\n    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),\n  },\n  (table) => [\n    index('runners_runner_sessions_kind_created_id_idx').on(\n      table.registrationTokenKind,\n      table.createdAt,\n      table.id,\n    ),\n    check(\n      'runners_runner_sessions_claims_ck',\n      sql`${table.claimsUsed} >= 0 AND ((${table.registrationTokenKind} = 'manual' AND ${table.maxClaims} IS NULL) OR (${table.registrationTokenKind} in ('ephemeral', 'activation') AND ${table.maxClaims} IS NOT NULL AND ${table.maxClaims} > 0 AND ${table.claimsUsed} <= ${table.maxClaims}))`,\n    ),\n    check(\n      'runners_runner_sessions_link_ck',\n      sql`((${table.registrationTokenKind} = 'manual' AND ${table.runnerInstanceId} IS NULL AND ${table.provisionerId} IS NULL AND ${table.providerRunnerId} IS NULL) OR (${table.registrationTokenKind} = 'ephemeral' AND ${table.runnerInstanceId} IS NULL AND ${table.provisionerId} IS NOT NULL AND ${table.providerRunnerId} IS NOT NULL) OR (${table.registrationTokenKind} = 'activation' AND ${table.runnerInstanceId} IS NOT NULL AND ${table.provisionerId} IS NOT NULL AND ${table.providerRunnerId} IS NOT NULL))`,\n    ),\n    index('runners_runner_sessions_provider_runner_updated_idx')\n      .on(table.workspaceId, table.provisionerId, table.providerRunnerId, table.updatedAt)\n      .where(sql`\"provisioner_id\" IS NOT NULL`),\n  ],\n);\n\nexport type RunnerSessionDb = typeof runnerSessions.$inferSelect;\nexport type RunnerSessionInsertDb = typeof runnerSessions.$inferInsert;\n\nexport function toRunnerSession(row: RunnerSessionDb): RunnerSession {\n  if (row.scope !== 'workspace') {\n    throw new Error(`Unexpected runner session scope: ${row.scope}`);\n  }\n\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    scope: row.scope,\n    registrationTokenId: row.registrationTokenId,\n    registrationTokenKind: row.registrationTokenKind,\n    runnerInstanceId: row.runnerInstanceId,\n    provisionerId: row.provisionerId,\n    providerRunnerId: row.providerRunnerId,\n    labels: row.labels,\n    toolCapabilities: row.toolCapabilities,\n    toolCapabilitiesReportedAt: row.toolCapabilitiesReportedAt,\n    maxClaims: row.maxClaims,\n    claimsUsed: row.claimsUsed,\n    revokedAt: row.revokedAt,\n    createdAt: row.createdAt,\n    updatedAt: row.updatedAt,\n  };\n}\n"],"names":["uuidv7PrimaryKey","sql","check","index","integer","jsonb","pgEnum","text","timestamp","uuid","pgTable","runnerSessionScopeEnum","runnerSessionRegistrationTokenKindEnum","runnerSessions","id","workspaceId","notNull","scope","default","registrationTokenId","registrationTokenKind","runnerInstanceId","provisionerId","providerRunnerId","labels","array","toolCapabilities","$type","toolCapabilitiesReportedAt","withTimezone","maxClaims","claimsUsed","revokedAt","createdAt","defaultNow","updatedAt","table","on","where","toRunnerSession","row","Error"],"mappings":"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"}

package/dist/db/schema/running-job-executions.d.ts

@@ -155,8 +155,8 @@ export declare const runningJobExecutions: import("drizzle-orm/pg-core").PgTable
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        provisionedRunnerId: import("drizzle-orm/pg-core").PgColumn<{
-            name: "provisioned_runner_id";
+        providerRunnerId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "provider_runner_id";
             tableName: "running_jobs";
             dataType: "string";
             columnType: "PgText";

package/dist/db/schema/running-job-executions.js

@@ -13,7 +13,7 @@ export const runningJobExecutions = pgTable('running_jobs', {
     projectId: uuid('project_id').notNull(),
     runnerSessionId: uuid('runner_session_id').notNull().references(()=>runnerSessions.id),
     provisionerId: uuid('provisioner_id'),
-    provisionedRunnerId: text('provisioned_runner_id'),
+    providerRunnerId: text('provider_runner_id'),
     requiredLabels: text('required_labels').array().notNull(),
     runnerLabels: text('runner_labels').array().notNull(),
     startedAt: timestamp('started_at', {
@@ -31,11 +31,11 @@ export const runningJobExecutions = pgTable('running_jobs', {
 }, (table)=>[
         index('runners_running_jobs_no_first_heartbeat_started_idx').on(table.startedAt).where(sql`"first_heartbeat_at" IS NULL`),
         index('runners_running_jobs_last_heartbeat_at_idx').on(table.lastHeartbeatAt),
-        index('runners_running_jobs_provisioned_runner_started_idx').on(table.workspaceId, table.provisionerId, table.provisionedRunnerId, table.startedAt.desc()).where(sql`"provisioner_id" IS NOT NULL`),
-        index('runners_running_jobs_cancellation_requested_idx').on(table.workspaceId, table.provisionerId, table.provisionedRunnerId).where(sql`"cancellation_requested_at" IS NOT NULL`),
+        index('runners_running_jobs_provider_runner_started_idx').on(table.workspaceId, table.provisionerId, table.providerRunnerId, table.startedAt.desc()).where(sql`"provisioner_id" IS NOT NULL`),
+        index('runners_running_jobs_cancellation_requested_idx').on(table.workspaceId, table.provisionerId, table.providerRunnerId).where(sql`"cancellation_requested_at" IS NOT NULL`),
         index('runners_running_jobs_job_id_idx').on(table.jobId),
         index('runners_running_jobs_runner_session_id_idx').on(table.runnerSessionId),
-        check('runners_running_jobs_link_ck', sql`(${table.provisionerId} IS NULL) = (${table.provisionedRunnerId} IS NULL)`)
+        check('runners_running_jobs_link_ck', sql`(${table.provisionerId} IS NULL) = (${table.providerRunnerId} IS NULL)`)
     ]);
 
 //# sourceMappingURL=running-job-executions.js.map