@opengeni/db 0.27.8 → 0.27.11

package/drizzle/0171_social_connection_subject_ownership.sql

@@ -0,0 +1,53 @@
+-- deployment-mode: rolling
+-- Extend first-party social credentials with the same workspace/personal ownership boundary as MCP connections.
+
+ALTER TABLE social_connections
+  ADD COLUMN subject_id text;
+
+DROP INDEX social_connections_workspace_provider_handle_idx;
+CREATE UNIQUE INDEX social_connections_workspace_provider_handle_idx
+  ON social_connections (workspace_id, provider, account_handle)
+  WHERE subject_id IS NULL;
+CREATE UNIQUE INDEX social_connections_subject_provider_handle_idx
+  ON social_connections (workspace_id, subject_id, provider)
+  WHERE subject_id IS NOT NULL;
+CREATE INDEX social_connections_subject_provider_status_idx
+  ON social_connections (workspace_id, subject_id, provider, status);
+
+DROP POLICY workspace_isolation ON social_connections;
+CREATE POLICY workspace_isolation ON social_connections
+  USING (
+    opengeni_private.workspace_rls_visible(account_id, workspace_id)
+    AND (
+      subject_id IS NULL
+      OR subject_id = nullif(current_setting('opengeni.subject_id', true), '')
+    )
+  )
+  WITH CHECK (
+    opengeni_private.workspace_rls_visible(account_id, workspace_id)
+    AND (
+      subject_id IS NULL
+      OR subject_id = nullif(current_setting('opengeni.subject_id', true), '')
+    )
+  );
+
+DROP POLICY workspace_isolation ON social_posts;
+CREATE POLICY workspace_isolation ON social_posts
+  USING (
+    opengeni_private.workspace_rls_visible(account_id, workspace_id)
+    AND EXISTS (
+      SELECT 1
+      FROM social_connections connection
+      WHERE connection.id = social_posts.connection_id
+        AND connection.workspace_id = social_posts.workspace_id
+    )
+  )
+  WITH CHECK (
+    opengeni_private.workspace_rls_visible(account_id, workspace_id)
+    AND EXISTS (
+      SELECT 1
+      FROM social_connections connection
+      WHERE connection.id = social_posts.connection_id
+        AND connection.workspace_id = social_posts.workspace_id
+    )
+  );

package/drizzle/0172_retire_model_visible_github_token.sql

@@ -0,0 +1,86 @@
+-- deployment-mode: maintenance
+-- GitHub App installation credentials are host-owned run material. Retire the
+-- model-visible github_token MCP tool from every durable session selection and
+-- prevent an old writer from reintroducing it after the coordinated cutover.
+
+UPDATE "sessions"
+SET "first_party_mcp_tools" = "first_party_mcp_tools" - 'github_token'
+WHERE "first_party_mcp_tools" ? 'github_token';
+
+ALTER TABLE "sessions"
+  ALTER COLUMN "first_party_mcp_tools"
+  SET DEFAULT '[
+    "set_session_title",
+    "goal_set",
+    "goal_update",
+    "goal_complete",
+    "goal_pause",
+    "memory_search",
+    "memory_save",
+    "memory_correct",
+    "preference_registry_summary",
+    "preference_registry_get",
+    "sandboxes_list",
+    "sandbox_attach",
+    "sandbox_swap",
+    "run_on",
+    "sandbox_provision",
+    "rig_list",
+    "rig_get",
+    "rig_propose_change",
+    "rig_verify",
+    "rig_promote",
+    "sessions_list",
+    "session_get",
+    "session_events",
+    "session_create",
+    "session_send_message",
+    "session_pause",
+    "session_resume",
+    "session_steer",
+    "set_other_session_title",
+    "variable_set_list",
+    "environment_list",
+    "variable_set_set_variable",
+    "environment_set_variable",
+    "github_connect_link",
+    "github_repositories_list",
+    "social_connections_list",
+    "social_posts_recent",
+    "social_daily_analysis_context",
+    "social_search_live",
+    "social_mentions_live",
+    "social_thread_fetch",
+    "social_posts_sync",
+    "social_post_reply",
+    "scheduled_tasks_list",
+    "scheduled_tasks_get",
+    "scheduled_tasks_create",
+    "scheduled_tasks_update",
+    "scheduled_tasks_pause",
+    "scheduled_tasks_resume",
+    "scheduled_tasks_trigger",
+    "scheduled_tasks_delete",
+    "scheduled_task_runs_list",
+    "slack_bot_list_channels",
+    "slack_bot_channel_history",
+    "slack_bot_thread_replies",
+    "slack_bot_list_users",
+    "slack_bot_list_files",
+    "slack_bot_file_info",
+    "slack_bot_file_content",
+    "slack_bot_post_message",
+    "slack_bot_delete_message",
+    "artifacts_list",
+    "artifacts_get_source",
+    "artifacts_create",
+    "artifacts_publish",
+    "artifacts_rollback"
+  ]'::jsonb;
+
+ALTER TABLE "sessions"
+  DROP CONSTRAINT IF EXISTS "sessions_first_party_mcp_tools_no_model_credentials_chk";
+
+ALTER TABLE "sessions"
+  ADD CONSTRAINT "sessions_first_party_mcp_tools_no_model_credentials_chk"
+  CHECK (NOT ("first_party_mcp_tools" @> '["github_token"]'::jsonb));

package/drizzle/0173_codex_auth_boundaries.sql

@@ -0,0 +1,107 @@
+-- deployment-mode: maintenance
+
+SET LOCAL lock_timeout = '5s';
+SET LOCAL statement_timeout = '10min';
+
+-- Reject mixed-version writers before locking, then repeat after the locks to
+-- close the connect-before-lock race. The deployment must keep API and workers
+-- stopped until the new application version is active.
+DO $codex_boundaries_writer_drain_before_lock$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app')
+    AND EXISTS (
+      SELECT 1
+      FROM pg_stat_activity
+      WHERE datname = current_database()
+        AND usename = 'opengeni_app'
+        AND pid <> pg_backend_pid()
+    )
+  THEN
+    RAISE EXCEPTION
+      'Codex authentication boundaries activation requires all opengeni_app sessions to be stopped'
+      USING ERRCODE = '55000';
+  END IF;
+END
+$codex_boundaries_writer_drain_before_lock$;
+
+LOCK TABLE "codex_subscription_credentials" IN ACCESS EXCLUSIVE MODE;
+LOCK TABLE "session_history_items" IN ACCESS EXCLUSIVE MODE;
+LOCK TABLE "agent_run_states" IN ACCESS EXCLUSIVE MODE;
+
+DO $codex_boundaries_writer_drain_after_lock$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app')
+    AND EXISTS (
+      SELECT 1
+      FROM pg_stat_activity
+      WHERE datname = current_database()
+        AND usename = 'opengeni_app'
+        AND pid <> pg_backend_pid()
+    )
+  THEN
+    RAISE EXCEPTION
+      'Codex authentication boundaries activation requires all opengeni_app sessions to be stopped'
+      USING ERRCODE = '55000';
+  END IF;
+END
+$codex_boundaries_writer_drain_after_lock$;
+
+-- One optional workspace credential for ChatGPT connected Apps. This pointer is
+-- intentionally separate from inference rotation and starts unset.
+CREATE UNIQUE INDEX "codex_subscription_credentials_workspace_account_id_idx"
+  ON "codex_subscription_credentials" ("workspace_id", "account_id", "id");
+
+CREATE TABLE "codex_apps_settings" (
+  "id" uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  "account_id" uuid NOT NULL REFERENCES "managed_accounts"("id") ON DELETE CASCADE,
+  "workspace_id" uuid NOT NULL REFERENCES "workspaces"("id") ON DELETE CASCADE,
+  "credential_id" uuid,
+  "version" integer NOT NULL DEFAULT 1,
+  "designated_at" timestamptz,
+  "updated_at" timestamptz NOT NULL DEFAULT now(),
+  CONSTRAINT "codex_apps_settings_workspace_account_fk"
+    FOREIGN KEY ("workspace_id", "account_id")
+    REFERENCES "workspaces"("id", "account_id") ON DELETE CASCADE,
+  CONSTRAINT "codex_apps_settings_credential_scope_fk"
+    FOREIGN KEY ("workspace_id", "account_id", "credential_id")
+    REFERENCES "codex_subscription_credentials"("workspace_id", "account_id", "id")
+    ON DELETE CASCADE,
+  CONSTRAINT "codex_apps_settings_designation_shape_chk" CHECK (
+    "version" > 0 AND (
+      ("credential_id" IS NULL AND "designated_at" IS NULL)
+      OR
+      ("credential_id" IS NOT NULL AND "designated_at" IS NOT NULL)
+    )
+  )
+);
+
+CREATE UNIQUE INDEX "codex_apps_settings_workspace_idx"
+  ON "codex_apps_settings" ("workspace_id");
+
+ALTER TABLE "codex_apps_settings" ENABLE ROW LEVEL SECURITY;
+ALTER TABLE "codex_apps_settings" FORCE ROW LEVEL SECURITY;
+CREATE POLICY workspace_isolation ON "codex_apps_settings"
+  USING (opengeni_private.workspace_rls_visible(account_id, workspace_id))
+  WITH CHECK (opengeni_private.workspace_rls_visible(account_id, workspace_id));
+
+-- Remove the false credential/history relation and the obsolete
+-- connector-aware inference cache. Provider rejection receipts remain.
+ALTER TABLE "session_history_items"
+  DROP COLUMN "producer_codex_credential_id";
+ALTER TABLE "agent_run_states"
+  DROP COLUMN "frozen_codex_credential_id";
+ALTER TABLE "codex_subscription_credentials"
+  DROP COLUMN "connector_namespaces",
+  DROP COLUMN "connectors_checked_at";
+
+DO $$
+DECLARE
+  target_schema text := current_schema();
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    EXECUTE format(
+      'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE %I.codex_apps_settings TO opengeni_app',
+      target_schema
+    );
+  END IF;
+END $$;

package/drizzle/0174_session_wake_live_interruption.sql

@@ -0,0 +1,80 @@
+-- deployment-mode: rolling
+-- Historical, fully quiesced interruptions are audit evidence, not live control work.
+
+SET lock_timeout = '5s';
+SET statement_timeout = '10min';
+
+DROP FUNCTION opengeni_private.claim_session_workflow_wakes(integer);
+
+DO $migration$
+DECLARE target_schema text := current_schema();
+BEGIN
+  EXECUTE format($create$
+    CREATE FUNCTION opengeni_private.claim_session_workflow_wakes(p_limit integer)
+    RETURNS TABLE (
+      account_id uuid,
+      workspace_id uuid,
+      session_id uuid,
+      temporal_workflow_id text,
+      wake_revision bigint,
+      interruption_requested boolean
+    )
+    LANGUAGE plpgsql
+    SECURITY DEFINER
+    SET search_path = pg_catalog
+    AS $function$
+    BEGIN
+      RETURN QUERY
+        WITH due AS (
+          SELECT o.session_id
+          FROM %1$I.session_workflow_wake_outbox o
+          WHERE o.wake_revision > o.delivered_revision
+            AND o.next_attempt_at <= now()
+          ORDER BY o.next_attempt_at, o.updated_at, o.session_id
+          FOR UPDATE SKIP LOCKED
+          LIMIT greatest(1, least(coalesce(p_limit, 100), 1000))
+        )
+        UPDATE %1$I.session_workflow_wake_outbox o
+        SET attempts = o.attempts + 1,
+            next_attempt_at = now() + make_interval(
+              secs => least(300, greatest(1, power(2, least(o.attempts, 8))::integer))
+            ),
+            updated_at = now()
+        FROM due
+        WHERE o.session_id = due.session_id
+        RETURNING o.account_id, o.workspace_id, o.session_id,
+          o.temporal_workflow_id, o.wake_revision,
+          o.control_revision > o.delivered_revision
+          OR EXISTS (
+            SELECT 1
+            FROM %1$I.session_attempt_interruptions interruption
+            JOIN %1$I.session_turn_attempts attempt
+              ON attempt.workspace_id = interruption.workspace_id
+             AND attempt.session_id = interruption.session_id
+             AND attempt.id = interruption.attempt_id
+            WHERE interruption.workspace_id = o.workspace_id
+              AND interruption.session_id = o.session_id
+              AND (
+                interruption.state IN ('pending', 'delivered', 'acknowledged')
+                OR (
+                  interruption.state IN ('settled', 'rejected_stale')
+                  AND attempt.quiesced_at IS NULL
+                )
+              )
+          ) AS interruption_requested;
+    END $function$;
+  $create$, target_schema);
+END $migration$;
+
+REVOKE ALL ON FUNCTION opengeni_private.claim_session_workflow_wakes(integer) FROM PUBLIC;
+
+DO $$
+BEGIN
+  IF EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'opengeni_app') THEN
+    GRANT EXECUTE ON FUNCTION opengeni_private.claim_session_workflow_wakes(integer)
+      TO opengeni_app;
+  END IF;
+END $$;
+
+RESET statement_timeout;
+RESET lock_timeout;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/db",
-  "version": "0.27.8",
+  "version": "0.27.11",
   "description": "OpenGeni persistence: Drizzle schema, RLS-scoped query layer, the SQL migration runner, and role provisioning.",
   "license": "Apache-2.0",
   "repository": {
@@ -50,9 +50,9 @@
     "prepublishOnly": "bash ../../scripts/prepublish-guard"
   },
   "dependencies": {
-    "@opengeni/codex": "^0.2.10",
-    "@opengeni/config": "^0.10.11",
-    "@opengeni/contracts": "^0.38.1",
+    "@opengeni/codex": "^0.2.11",
+    "@opengeni/config": "^0.10.14",
+    "@opengeni/contracts": "^0.38.3",
     "@opengeni/network": "^0.2.0",
     "drizzle-orm": "^0.45.2",
     "postgres": "^3.4.7"

package/src/codex-token-resolver.ts

@@ -3,7 +3,7 @@
 // Hoisted here from apps/worker/src/activities/codex-auth.ts so BOTH the worker
 // (turn-time bearer for the streamed run) AND the api (the /wham/usage quota-bar
 // reads) drive ONE resolver — no duplicated refresh/CAS/single-flight logic. The
-// worker re-exports buildCodexTokenResolver from this module for back-compat, so
+// worker re-exports buildCodexTokenResolver from @opengeni/db for back-compat, so
 // the agent-turn.ts call site is unchanged.
 //
 // Why @opengeni/db is the right home: the resolver only orchestrates accessors
@@ -35,15 +35,52 @@ import {
   refreshCodexToken,
 } from "@opengeni/codex";
 import { encryptEnvironmentValue } from "./environment-crypto";
-import {
-  loadCodexCredentialForRun,
-  recordCodexAccountUsage,
-  recordCodexTokenRefresh,
-  setCodexCredentialStatus,
-  withCodexCredentialRefreshLock,
-  type CodexCredentialForRun,
-  type Database,
-} from "./index";
+import type { Database } from "./database";
+
+export type CodexCredentialTokens = {
+  accessToken: string;
+  refreshToken: string;
+  idToken: string;
+};
+
+export type CodexCredentialForRun = {
+  id: string;
+  version: number;
+  workspaceId: string;
+  tokens: CodexCredentialTokens;
+  chatgptAccountId: string | null;
+  scopes: string | null;
+  planType: string | null;
+  isFedramp: boolean;
+  expiresAt: Date | null;
+  lastRefreshAt: Date | null;
+  status: string;
+  lastError: string | null;
+};
+
+export type CodexAccountUsageSnapshot = {
+  primaryUsedPercent?: number | null;
+  primaryResetAt?: Date | null;
+  secondaryUsedPercent?: number | null;
+  secondaryResetAt?: Date | null;
+  checkedAt?: Date;
+  resetCreditAvailableCount?: number | null;
+  resetCreditsCheckedAt?: Date | null;
+};
+
+type CodexCredentialRefreshInput = {
+  id: string;
+  version: number;
+  workspaceId: string;
+  credentialEncrypted: string;
+  expiresAt: Date | null;
+  lastRefreshAt: Date;
+};
+
+type CodexCredentialStatusTarget = {
+  id: string;
+  version: number;
+};
 
 // Single-flight per CREDENTIAL INSTANCE (row id + version), process-module scope.
 // Keying by the loaded credential's id+version — NOT by workspaceId alone (P1-b) —
@@ -142,25 +179,37 @@ export async function withCodexTokenDeadline<T>(
 
 // Dependencies are injectable so the lifecycle logic (single-flight, staleness,
 // needs_relogin transition) is unit-testable without a database. Production uses
-// the real db + codex functions via the default bag.
+// the root composition wrapper supplies the real db + codex functions.
 export type CodexAuthDeps = {
-  loadCredential: typeof loadCodexCredentialForRun;
-  recordRefresh: typeof recordCodexTokenRefresh;
-  setStatus: typeof setCodexCredentialStatus;
+  loadCredential: (
+    db: Database,
+    settings: Settings,
+    workspaceId: string,
+    credentialId: string,
+  ) => Promise<CodexCredentialForRun | null>;
+  recordRefresh: (db: Database, input: CodexCredentialRefreshInput) => Promise<boolean>;
+  setStatus: (
+    db: Database,
+    workspaceId: string,
+    status: "active" | "needs_relogin" | "error",
+    lastError: string | null,
+    target: CodexCredentialStatusTarget,
+  ) => Promise<boolean>;
   refresh: typeof refreshCodexToken;
   encrypt: typeof encryptEnvironmentValue;
   keyBytes: typeof environmentsEncryptionKeyBytes;
-  withRefreshLock: typeof withCodexCredentialRefreshLock;
-};
-
-const defaultDeps: CodexAuthDeps = {
-  loadCredential: loadCodexCredentialForRun,
-  recordRefresh: recordCodexTokenRefresh,
-  setStatus: setCodexCredentialStatus,
-  refresh: refreshCodexToken,
-  encrypt: encryptEnvironmentValue,
-  keyBytes: environmentsEncryptionKeyBytes,
-  withRefreshLock: withCodexCredentialRefreshLock,
+  withRefreshLock: <T>(
+    db: Database,
+    workspaceId: string,
+    credentialId: string,
+    fn: (lockedDb: Database) => Promise<T>,
+  ) => Promise<T>;
+  recordUsage?: (
+    db: Database,
+    workspaceId: string,
+    credentialId: string,
+    snapshot: CodexAccountUsageSnapshot,
+  ) => Promise<boolean>;
 };
 
 export function buildCodexTokenResolver(
@@ -173,7 +222,7 @@ export function buildCodexTokenResolver(
   // 0 rows against the now-inactive row — so a refresh racing a switch can never
   // clobber the newly-active account. The single-flight map needs zero change.
   credentialId: string,
-  deps: CodexAuthDeps = defaultDeps,
+  deps: CodexAuthDeps,
 ): { getToken: () => Promise<CodexTokenSnapshot>; refresh: () => Promise<CodexTokenSnapshot> } {
   const snapshot = (cred: CodexCredentialForRun): CodexTokenSnapshot => ({
     accessToken: cred.tokens.accessToken,
@@ -336,9 +385,10 @@ export async function fetchCodexUsageForAccount(
   settings: Settings,
   workspaceId: string,
   credentialId: string,
+  deps: CodexAuthDeps,
   fetchImpl: CodexFetch = fetch,
 ): Promise<CodexUsagePayload> {
-  const resolver = buildCodexTokenResolver(db, settings, workspaceId, credentialId);
+  const resolver = buildCodexTokenResolver(db, settings, workspaceId, credentialId, deps);
   let token: CodexTokenSnapshot;
   try {
     token = await resolver.getToken();
@@ -373,27 +423,29 @@ export async function fetchCodexUsageForAccount(
     // cached without erasing or falsely refreshing the last valid quota truth.
     // Cache-write is best-effort: a disconnect under us (false) or a transient
     // write error must NOT sink the freshly-read result we are about to return.
-    await recordCodexAccountUsage(db, workspaceId, credentialId, {
-      ...(parsedQuota
-        ? {
-            primaryUsedPercent: normalized.fiveHour?.percent ?? null,
-            primaryResetAt: normalized.fiveHour?.resetAt
-              ? new Date(normalized.fiveHour.resetAt)
-              : null,
-            secondaryUsedPercent: normalized.weekly?.percent ?? null,
-            secondaryResetAt: normalized.weekly?.resetAt
-              ? new Date(normalized.weekly.resetAt)
-              : null,
-            checkedAt,
-          }
-        : {}),
-      ...(normalized.rateLimitResetCredits
-        ? {
-            resetCreditAvailableCount: normalized.rateLimitResetCredits.availableCount,
-            resetCreditsCheckedAt: checkedAt,
-          }
-        : {}),
-    }).catch(() => undefined);
+    await deps
+      .recordUsage?.(db, workspaceId, credentialId, {
+        ...(parsedQuota
+          ? {
+              primaryUsedPercent: normalized.fiveHour?.percent ?? null,
+              primaryResetAt: normalized.fiveHour?.resetAt
+                ? new Date(normalized.fiveHour.resetAt)
+                : null,
+              secondaryUsedPercent: normalized.weekly?.percent ?? null,
+              secondaryResetAt: normalized.weekly?.resetAt
+                ? new Date(normalized.weekly.resetAt)
+                : null,
+              checkedAt,
+            }
+          : {}),
+        ...(normalized.rateLimitResetCredits
+          ? {
+              resetCreditAvailableCount: normalized.rateLimitResetCredits.availableCount,
+              resetCreditsCheckedAt: checkedAt,
+            }
+          : {}),
+      })
+      .catch(() => undefined);
   }
 
   return normalized;
@@ -418,9 +470,10 @@ export async function fetchCodexRateLimitResetCreditsForAccount(
   settings: Settings,
   workspaceId: string,
   credentialId: string,
+  deps: CodexAuthDeps,
   fetchImpl: CodexFetch = fetch,
 ): Promise<CodexRateLimitResetCreditsAccountResult> {
-  const resolver = buildCodexTokenResolver(db, settings, workspaceId, credentialId);
+  const resolver = buildCodexTokenResolver(db, settings, workspaceId, credentialId, deps);
   let token: CodexTokenSnapshot;
   try {
     token = await resolver.getToken();