@opengeni/db 1.4.0 → 1.4.2

package/src/modal-native-live-origin.ts

@@ -0,0 +1,148 @@
+import { sql } from "drizzle-orm";
+import { rawRows, type Database } from "./database";
+
+/** Structural V2 correlation scope. This is deliberately NOT an actor/grant. */
+export type ModalNativeLiveOriginScope = Readonly<{
+  version: 2;
+  declarationId: string;
+  planId: string;
+  creatorId: string;
+  accountId: string;
+  workspaceId: string;
+  sessionId: string;
+  turnId: string;
+  attemptId: string;
+  executionGeneration: number;
+  triggerEventId: string;
+  sandboxGroupId: string;
+  routeKind: "home";
+  routeTargetId: null;
+  routeEpoch: number;
+}>;
+
+export type ModalNativeLiveOriginProjection = Readonly<{
+  version: 1;
+  scope: ModalNativeLiveOriginScope;
+  initiator: {
+    kind: "subject" | "service";
+    subjectId: string;
+    initiatingHumanSubjectId: string;
+  };
+  membership: {
+    id: string;
+    authorizationRevision: string;
+    basis: "workspace_membership" | "personal_workspace";
+  };
+  acceptedAuthority: {
+    epoch: number;
+    visibility: "user_private" | "workspace_shared";
+    ownerOrganizationMembershipId: string | null;
+  };
+  currentAuthority: {
+    epoch: number;
+    executionEpoch: number;
+    visibility: "user_private" | "workspace_shared";
+    ownerSubjectId: string | null;
+    ownerOrganizationMembershipId: string | null;
+  };
+  control: { workspaceRevision: string; sessionVersion: string };
+  execution: { workflowId: string; workflowRunId: string; activityId: string };
+  providerRecoveryCount: 0 | 1 | 2 | 3 | 4 | 5;
+  checkedAt: string;
+}>;
+
+export type ModalNativeLiveOriginResult =
+  | { kind: "live"; projection: ModalNativeLiveOriginProjection }
+  | { kind: "fenced" }
+  | {
+      kind: "unsupported";
+      reason: "invalid_scope" | "human_unavailable" | "external_authority" | "not_premodel";
+    };
+
+const keys = [
+  "version",
+  "declarationId",
+  "planId",
+  "creatorId",
+  "accountId",
+  "workspaceId",
+  "sessionId",
+  "turnId",
+  "attemptId",
+  "executionGeneration",
+  "triggerEventId",
+  "sandboxGroupId",
+  "routeKind",
+  "routeTargetId",
+  "routeEpoch",
+] as const;
+const ids = [
+  "declarationId",
+  "planId",
+  "creatorId",
+  "accountId",
+  "workspaceId",
+  "sessionId",
+  "turnId",
+  "attemptId",
+  "triggerEventId",
+  "sandboxGroupId",
+] as const;
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+function scopeSnapshot(value: ModalNativeLiveOriginScope): ModalNativeLiveOriginScope | null {
+  if (!value || typeof value !== "object") return null;
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(value).length !== keys.length) return null;
+  const copy: Record<string, unknown> = {};
+  for (const key of keys) {
+    const descriptor = descriptors[key];
+    if (!descriptor || !("value" in descriptor)) return null;
+    copy[key] = descriptor.value;
+  }
+  if (ids.some((key) => typeof copy[key] !== "string" || !uuid.test(copy[key] as string)))
+    return null;
+  if (
+    copy.version !== 2 ||
+    copy.routeKind !== "home" ||
+    copy.routeTargetId !== null ||
+    copy.creatorId === copy.attemptId ||
+    copy.creatorId === copy.planId ||
+    !Number.isSafeInteger(copy.executionGeneration) ||
+    (copy.executionGeneration as number) < 1 ||
+    (copy.executionGeneration as number) > 2_147_483_647 ||
+    !Number.isSafeInteger(copy.routeEpoch) ||
+    (copy.routeEpoch as number) < 0 ||
+    (copy.routeEpoch as number) > 2_147_483_647
+  )
+    return null;
+  return Object.freeze(copy) as ModalNativeLiveOriginScope;
+}
+
+/**
+ * Private-server integration primitive, NOT host authentication or a grant.
+ * The caller must authenticate the exact host request separately and consume
+ * this projection in this SAME transaction. No native/provider awaits here.
+ * Enter before taking any tenancy/control/session/lease lock: SQL acquires the
+ * organization-membership -> tenancy -> canonical control/row prefix itself.
+ * Preserves all subject and tenant GUCs. SQL uncertainty propagates (including
+ * 55P03); no failed/aborted transaction is reported as successful admission.
+ */
+export async function lockLiveNativeOriginalOriginTx(
+  scopedTx: Database,
+  scope: ModalNativeLiveOriginScope,
+): Promise<ModalNativeLiveOriginResult> {
+  if (typeof (scopedTx as Database & { rollback?: unknown }).rollback !== "function") {
+    throw new Error("LIVE native origin projection requires an existing transaction");
+  }
+  const snapshot = scopeSnapshot(scope);
+  if (!snapshot) return { kind: "unsupported", reason: "invalid_scope" };
+  const [row] = await rawRows<{ result: ModalNativeLiveOriginResult }>(
+    scopedTx,
+    sql`select lock_live_native_original_origin_v2(${JSON.stringify(snapshot)}::jsonb) as result`,
+  );
+  if (!row || !["live", "fenced", "unsupported"].includes(row.result?.kind)) {
+    throw new Error("Invalid LIVE native origin database projection");
+  }
+  return row.result;
+}

package/src/provision-roles.ts

@@ -578,6 +578,8 @@ async function grantAppRoleIfSchemaExists(
     "prepare_organization_membership_protocol_settlements(jsonb)",
     "assert_active_managed_human_organization_membership(uuid,text)",
     "resolve_workspace_writer_grant_identity(uuid,text)",
+    "lock_live_native_original_origin_v2(jsonb)",
+    "modal_native_origin_member_read_active(uuid,text)",
     "prepare_workspace_membership_removal_settlements(jsonb)",
     "workspace_membership_removal_command(jsonb)",
     "get_organization_retention_policy(uuid,text)",
@@ -2105,6 +2107,16 @@ BEGIN
         REVOKE ALL ON FUNCTION opengeni_private.list_pending_modal_provider_creates() FROM PUBLIC;
       END IF;
     END IF;
+    IF to_regclass('opengeni_private.modal_native_origin_read_capabilities') IS NOT NULL THEN
+      EXECUTE format('REVOKE ALL ON TABLE opengeni_private.modal_native_origin_read_capabilities FROM %I', ${literal(role)});
+      EXECUTE format('REVOKE ALL (%s) ON TABLE opengeni_private.modal_native_origin_read_capabilities FROM %I',
+        (SELECT string_agg(quote_ident(attname), ',') FROM pg_attribute
+          WHERE attrelid='opengeni_private.modal_native_origin_read_capabilities'::regclass AND attnum>0 AND NOT attisdropped), ${literal(role)});
+      REVOKE ALL ON TABLE opengeni_private.modal_native_origin_read_capabilities FROM PUBLIC;
+      EXECUTE format('REVOKE ALL (%s) ON TABLE opengeni_private.modal_native_origin_read_capabilities FROM PUBLIC',
+        (SELECT string_agg(quote_ident(attname), ',') FROM pg_attribute
+          WHERE attrelid='opengeni_private.modal_native_origin_read_capabilities'::regclass AND attnum>0 AND NOT attisdropped));
+    END IF;
     IF to_regclass('opengeni_private.sandbox_recovery_rollout') IS NOT NULL THEN
       -- Migration may precede this role's creation. Converge only read access;
       -- runtime identities and PUBLIC never receive recovery activation writes.

package/src/runtime-posture.ts

@@ -609,6 +609,8 @@ const PRIVATE_SESSION_CREATE_CAPABILITY_ROUTINES = [
   "close_private_session_create_capability(uuid)",
 ] as const;
 const SESSION_AUTHORITY_ROUTINES = new Set<string>([
+  "lock_live_native_original_origin_v2(jsonb)",
+  "modal_native_origin_member_read_active(uuid, text)",
   LEGACY_FORK_SESSION_CONTENT_ROUTINE,
   FORK_SESSION_CONTENT_ROUTINE,
   MESSAGE_FORK_SESSION_CONTENT_ROUTINE,
@@ -712,6 +714,8 @@ const UNIFIED_KNOWLEDGE_AUTHORITY_TABLES = [
   "documents",
 ] as const;
 export const RUNTIME_TARGET_SCHEMA_CAPABILITY_ROUTINES = [
+  "lock_live_native_original_origin_v2(jsonb)",
+  "modal_native_origin_member_read_active(uuid, text)",
   ...CLAUDE_SUBSCRIPTION_CAPABILITY_ROUTINES,
   "maintain_usage_allowances(integer, integer)",
   "usage_allowance_command(jsonb)",
@@ -2135,15 +2139,15 @@ export async function inspectRuntimeDatabasePosture(
             -- Column-only grants on capability tables are also unsafe; a pin
             -- table must remain EXECUTE-only even after column ACL drift.
             (has_table_privilege(current_user, c.oid, 'SELECT') or
-              ((c.relname in ('modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
+              ((c.relname in ('modal_native_origin_read_capabilities','modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
                 c.relname in (select jsonb_array_elements_text(${JSON.stringify(RUNTIME_ALLOWANCE_PRIVATE_TABLES)}::jsonb))) and
                 has_any_column_privilege(current_user, c.oid, 'SELECT'))) as can_select,
             (has_table_privilege(current_user, c.oid, 'INSERT') or
-              ((c.relname in ('modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
+              ((c.relname in ('modal_native_origin_read_capabilities','modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
                 c.relname in (select jsonb_array_elements_text(${JSON.stringify(RUNTIME_ALLOWANCE_PRIVATE_TABLES)}::jsonb))) and
                 has_any_column_privilege(current_user, c.oid, 'INSERT'))) as can_insert,
             (has_table_privilege(current_user, c.oid, 'UPDATE') or
-              ((c.relname in ('modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
+              ((c.relname in ('modal_native_origin_read_capabilities','modal_inventory_read_capabilities','usage_allowance_capabilities','session_import_batches', ${ARTIFACT_PINS_TABLE}) or
                 c.relname in (select jsonb_array_elements_text(${JSON.stringify(RUNTIME_ALLOWANCE_PRIVATE_TABLES)}::jsonb))) and
                 has_any_column_privilege(current_user, c.oid, 'UPDATE'))) as can_update,
             has_table_privilege(current_user, c.oid, 'DELETE') as can_delete,
@@ -2190,6 +2194,7 @@ export async function inspectRuntimeDatabasePosture(
               'session_file_read_capabilities',
               'session_import_batches',
               'modal_inventory_read_capabilities',
+              'modal_native_origin_read_capabilities',
               ${AUTOMATIC_SESSION_TITLE_FANOUT_OUTBOX_TABLE},
               ${VERIFIED_SIGNUP_TRIAL_SWITCH_TABLE},
               'credit_promotion_policy_revisions',
@@ -4235,6 +4240,30 @@ export function evaluateRuntimeDatabasePosture(
   ) {
     violations.push("usage allowance attribution receipts lack same-owner FORCE-RLS isolation");
   }
+  const nativeOriginCapability = posture.privateTables.find(
+    (table) => table.name === "modal_native_origin_read_capabilities",
+  );
+  const nativeOriginRoutineInstalled = posture.targetRoutines.some(
+    (routine) => routine.name === "lock_live_native_original_origin_v2(jsonb)",
+  );
+  if (
+    (nativeOriginRoutineInstalled || nativeOriginCapability) &&
+    (!nativeOriginCapability ||
+      nativeOriginCapability.owner === expectedRole ||
+      nativeOriginCapability.owner !== tableByName.get("sessions")?.owner ||
+      nativeOriginCapability.owner !== tableByName.get("organization_memberships")?.owner ||
+      !nativeOriginCapability.rlsEnabled ||
+      !nativeOriginCapability.rlsForced ||
+      !nativeOriginCapability.rlsActive ||
+      nativeOriginCapability.select ||
+      nativeOriginCapability.insert ||
+      nativeOriginCapability.update ||
+      nativeOriginCapability.delete ||
+      nativeOriginCapability.truncate ||
+      nativeOriginCapability.references ||
+      nativeOriginCapability.trigger)
+  )
+    violations.push("Native LIVE-origin read capability has unsafe owner, RLS or privileges");
   const modalInventoryCapability = posture.privateTables.find(
     (table) => table.name === "modal_inventory_read_capabilities",
   );

package/src/sandbox-interaction-idle.ts

@@ -0,0 +1,91 @@
+import { sql } from "drizzle-orm";
+import { rawRows, withRlsContext, type Database } from "./database";
+
+export const INTERACTION_ONLY_IDLE_BUCKETS = ["lt_30m", "30m_2h", "2h_6h", "gte_6h"] as const;
+export type InteractionOnlyIdleBucket = (typeof INTERACTION_ONLY_IDLE_BUCKETS)[number];
+
+export type InteractionOnlyLeaseCandidate = {
+  accountId: string;
+  workspaceId: string;
+  sandboxGroupId: string;
+};
+
+export function interactionOnlyIdleBucket(idleMs: number): InteractionOnlyIdleBucket {
+  if (idleMs < 30 * 60_000) return "lt_30m";
+  if (idleMs < 2 * 60 * 60_000) return "30m_2h";
+  if (idleMs < 6 * 60 * 60_000) return "2h_6h";
+  return "gte_6h";
+}
+
+/**
+ * Read-only inventory of warm leases whose ONLY holders are Browser/Computer
+ * interaction holders, bucketed by time since the newest interaction activity
+ * (holder heartbeat, controller heartbeat, or last use). Interaction holders
+ * deliberately never expire by timestamp, so such a box stays warm until its
+ * session ends or the provider deadline; this makes that visible. Candidates
+ * come from the sanctioned cross-workspace warm-lease list; each workspace is
+ * then read under its own RLS scope. No lock beyond the snapshot is taken.
+ */
+export async function countInteractionOnlyWarmLeasesByIdle(
+  db: Database,
+  candidates: InteractionOnlyLeaseCandidate[],
+  options: { now?: Date; maxWorkspaces?: number } = {},
+): Promise<Record<InteractionOnlyIdleBucket, number>> {
+  const nowMs = (options.now ?? new Date()).getTime();
+  const counts = Object.fromEntries(INTERACTION_ONLY_IDLE_BUCKETS.map((b) => [b, 0])) as Record<
+    InteractionOnlyIdleBucket,
+    number
+  >;
+  const byWorkspace = new Map<string, InteractionOnlyLeaseCandidate[]>();
+  for (const candidate of candidates) {
+    const key = `${candidate.accountId}:${candidate.workspaceId}`;
+    byWorkspace.set(key, [...(byWorkspace.get(key) ?? []), candidate]);
+  }
+  const workspaces = [...byWorkspace.values()].slice(0, options.maxWorkspaces ?? 500);
+  for (const group of workspaces) {
+    const { accountId, workspaceId } = group[0]!;
+    const groupIds = group.map((candidate) => candidate.sandboxGroupId);
+    const rows = await withRlsContext(
+      db,
+      { accountId, workspaceId },
+      async (scoped) =>
+        await rawRows<{ last_activity_at: Date | string | null }>(
+          scoped,
+          sql`
+            select max(greatest(
+              holder.last_heartbeat_at,
+              browser.controller_heartbeat_at, browser.last_used_at,
+              computer.controller_heartbeat_at, computer.last_used_at
+            )) as last_activity_at
+            from sandbox_leases lease
+            join sandbox_lease_holders holder
+              on holder.lease_id = lease.id and holder.workspace_id = lease.workspace_id
+            left join browser_sessions browser
+              on holder.holder_id = 'browser-session:' || browser.id::text
+              and browser.workspace_id = lease.workspace_id
+            left join computer_sessions computer
+              on holder.holder_id = 'computer-session:' || computer.id::text
+              and computer.workspace_id = lease.workspace_id
+            where lease.account_id = ${accountId}
+              and lease.workspace_id = ${workspaceId}
+              and lease.sandbox_group_id in ${sql`(${sql.join(
+                groupIds.map((id) => sql`${id}`),
+                sql`, `,
+              )})`}
+              and lease.liveness = 'warm'
+            group by lease.id
+            having bool_and(holder.kind = 'interaction')
+          `,
+        ),
+      undefined,
+      "none",
+    );
+    for (const row of rows) {
+      const last = row.last_activity_at ? new Date(row.last_activity_at).getTime() : Number.NaN;
+      counts[
+        interactionOnlyIdleBucket(Number.isFinite(last) ? Math.max(0, nowMs - last) : Infinity)
+      ] += 1;
+    }
+  }
+  return counts;
+}

package/src/transcription-recordings.ts

@@ -1087,7 +1087,9 @@ export function assembleTranscriptionSegments(
           ).trim(),
     )
     .filter(Boolean)
-    .join("\n\n");
+    // Segments are fixed-length time cuts, not paragraphs: a boundary usually
+    // falls mid-sentence, so a long dictation must read as one continuous text.
+    .join(" ");
   const seen = new Set<string>();
   const combinedLanguages: string[] = [];
   for (const segment of ordered) {