@opengeni/db 6.2.0 → 6.3.0-canary.36927100590001

package/dist/archived-session-imports.d.ts

@@ -0,0 +1,115 @@
+import { AppendArchivedSessionEventsRequest, ImportArchivedSessionRequest, type ArchivedSessionImportEvent, type Session, type SessionEvent, type TurnInitiator, type TurnInitiatorContext, type Permission, type AccessGrant, type FileAsset } from "@opengeni/contracts";
+import { type Database } from "./database.js";
+type ArchivedImportDependencies = {
+    createSessionWithIdempotencyKeyResult: (db: Database, input: {
+        accountId: string;
+        workspaceId: string;
+        subjectId: string;
+        visibility: "user_private" | "workspace_shared";
+        createIdempotencyKey: string;
+        initialMessage: string;
+        resources: never[];
+        skills: never[];
+        tools: never[];
+        metadata: Record<string, unknown>;
+        createdBy: TurnInitiator;
+        createdByContext?: TurnInitiatorContext;
+        model: string;
+        reasoningEffort: "low";
+        latencyMode: "standard";
+        sandboxBackend: "none";
+        variableSetIds: string[];
+        firstPartyMcpTools: never[];
+        firstPartyMcpPermissions: never[];
+        beforeCreateCommit: (tx: Database, sessionId: string, context?: {
+            created: boolean;
+        }) => Promise<void>;
+    }) => Promise<{
+        denied: false;
+        created: boolean;
+        session: {
+            id: string;
+        };
+    } | {
+        denied: true;
+    }>;
+    getFilesForSubject: (db: Database, input: {
+        accountId: string;
+        workspaceId: string;
+        subjectId: string | null;
+        fileIds: readonly string[];
+    }) => Promise<FileAsset[]>;
+    getSession: (db: Database, workspaceId: string, sessionId: string) => Promise<Session | null>;
+    getWorkspaceGrant: (db: Database, subjectId: string, workspaceId: string) => Promise<AccessGrant | null>;
+    isCreateConflict: (error: unknown) => boolean;
+    isCreateUnavailable: (error: unknown) => boolean;
+};
+/** Bind canonical session/file helpers at the root composition, never by
+ * importing that barrel back into a reexported leaf. No permissive defaults. */
+export declare function createArchivedSessionImportPersistence(dependencies: ArchivedImportDependencies): {
+    importArchivedSession: (db: Database, input: Parameters<typeof importArchivedSession>[1]) => Promise<{
+        session: Session;
+        importId: string;
+        created: boolean;
+        nextOffset: number;
+        events: SessionEvent[];
+    }>;
+    appendArchivedSessionEvents: (db: Database, input: Parameters<typeof appendArchivedSessionEvents>[1]) => Promise<{
+        sessionId: string;
+        importId: string;
+        nextOffset: number;
+        replayed: boolean;
+        events: SessionEvent[];
+    }>;
+};
+export type ArchivedSessionImportErrorCode = "SESSION_IMPORT_CONFLICT" | "SESSION_IMPORT_OFFSET_CONFLICT" | "SESSION_IMPORT_NOT_FOUND" | "SESSION_IMPORT_INVALID_FILE" | "SESSION_IMPORTED_READ_ONLY";
+export declare class ArchivedSessionImportError extends Error {
+    readonly code: ArchivedSessionImportErrorCode;
+    readonly name = "ArchivedSessionImportError";
+    constructor(code: ArchivedSessionImportErrorCode);
+}
+export declare function assertSessionIsNotImported(session: Pick<Session, "importedArchive">): void;
+export declare function canonicalArchivedSessionImportHash(value: unknown): string;
+type ImportScope = {
+    accountId: string;
+    workspaceId: string;
+    subjectId: string;
+    /** Set only from verified request ownership, never from a payload label. */
+    fileOwnerSubjectId: string | null;
+    requireLiveSubject?: boolean;
+    apiKeyId?: string;
+    requiredPermission?: Permission;
+    beforeCommit?: (tx: Database) => Promise<void>;
+};
+/** JSON is already bounded by the contract; inspect nested resources as well as
+ * the usual top-level attachment refs. Never accept another workspace's file,
+ * even when its personal-file ACL happens to allow the importing human. */
+export declare function archivedSessionImportFileIds(events: readonly ArchivedSessionImportEvent[]): string[];
+declare function importArchivedSession(db: Database, input: ImportScope & {
+    payload: ImportArchivedSessionRequest;
+    createdBy: TurnInitiator;
+    createdByContext?: TurnInitiatorContext;
+}, dependencies: ArchivedImportDependencies): Promise<{
+    session: Session;
+    importId: string;
+    created: boolean;
+    nextOffset: number;
+    events: SessionEvent[];
+}>;
+declare function appendArchivedSessionEvents(db: Database, input: ImportScope & {
+    importId: string;
+    payload: AppendArchivedSessionEventsRequest;
+    /** A host authorization decision may happen before locking, but its target
+     * and mutable database authority are verified again after the prefix. */
+    sessionId: string;
+}, dependencies: ArchivedImportDependencies): Promise<{
+    sessionId: string;
+    importId: string;
+    nextOffset: number;
+    replayed: boolean;
+    events: SessionEvent[];
+}>;
+/** Scoped lookup only. Core authorizes the resolved target; another importer
+ * never receives a session identity just because its shared timeline is visible. */
+export declare function getArchivedSessionImportId(db: Database, workspaceId: string, subjectId: string, importId: string): Promise<string | null>;
+export {};

package/dist/automations.d.ts

@@ -4,6 +4,10 @@ export declare class AutomationDeliveryConflictError extends Error {
     readonly name = "AutomationDeliveryConflictError";
     constructor();
 }
+export declare class AutomationCredentialRestrictionConflictError extends Error {
+    readonly name = "AutomationCredentialRestrictionConflictError";
+    constructor();
+}
 export declare class AutomationRevisionConflictError extends Error {
     readonly name = "AutomationRevisionConflictError";
     constructor();
@@ -73,6 +77,8 @@ export declare function createAutomationTrigger(db: Database, input: {
     createdBySubjectId: string;
     request: CreateAutomationTriggerRequest;
     adapterId: string;
+    /** Canonical server-only creator restriction, never request metadata. */
+    credentialRestriction?: "developer_setup";
     /** Trusted database-only admission seam. Throwing rolls creation back. */
     beforeCreateCommit?: (tx: Database) => Promise<void>;
 }): Promise<AutomationTrigger>;
@@ -94,6 +100,8 @@ export declare function updateAutomationTrigger(db: Database, input: {
     triggerId: string;
     subjectId: string;
     request: UpdateAutomationTriggerRequest;
+    /** May add a canonical restriction; can never downgrade the stored ceiling. */
+    credentialRestriction?: "developer_setup";
     /** Trusted database-only admission seam. Throwing rolls the revision back. */
     beforeUpdateCommit?: (tx: Database) => Promise<void>;
 }): Promise<AutomationTrigger | null>;
@@ -110,6 +118,8 @@ export declare function recordAutomationEvent(db: Database, input: {
     deliveryKey: string;
     requestDigest: string;
     normalizedEvent: AutomationNormalizedEvent;
+    /** Trusted caller authority; never accepted from normalized adapter/event JSON. */
+    credentialRestriction?: "developer_setup";
     ignoredReason?: string | null;
 }): Promise<{
     event: AutomationStoredEvent;

package/dist/browser-deadline-checkpoints.d.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { type Database } from "./database.js";
+declare const Target: z.ZodObject<{
+    accountId: z.ZodUUID;
+    workspaceId: z.ZodUUID;
+    sandboxGroupId: z.ZodUUID;
+    leaseId: z.ZodUUID;
+    leaseEpoch: z.ZodNumber;
+    instanceId: z.ZodString;
+    browserSessionId: z.ZodUUID;
+    controllerGeneration: z.ZodString;
+}, z.core.$strip>;
+declare const Claim: z.ZodObject<{
+    operationId: z.ZodUUID;
+    state: z.ZodEnum<{
+        completed: "completed";
+        dispatched: "dispatched";
+        prepared: "prepared";
+    }>;
+}, z.core.$strip>;
+export type BrowserDeadlineCheckpointTarget = z.infer<typeof Target>;
+export type BrowserDeadlineCheckpointClaim = z.infer<typeof Claim>;
+/** Private, bounded system inventory. It contains no user session authority or profile bytes. */
+export declare function listBrowserDeadlineCheckpoints(db: Database, limit?: number): Promise<BrowserDeadlineCheckpointTarget[]>;
+/** The definer rechecks and locks the exact lease, holder, operation and controller.
+ * Preparing is allowed only after provider rotation is already requested. */
+export declare function browserDeadlineCheckpoint(db: Database, target: BrowserDeadlineCheckpointTarget, options?: {
+    prepare?: boolean;
+    touch?: boolean;
+}): Promise<BrowserDeadlineCheckpointClaim | null>;
+export {};

package/dist/browser-sessions.d.ts

@@ -2,6 +2,7 @@ import { BrowserSession, InteractionControllerBinding, type BrowserSessionCapabi
 import { type Database } from "./database.js";
 import { type BrowserStateArtifactCommitInput } from "./browser-state-artifacts.js";
 import * as schema from "./schema.js";
+import { type BrowserDeadlineCheckpointTarget } from "./browser-deadline-checkpoints.js";
 type BrowserSessionRow = typeof schema.browserSessions.$inferSelect;
 type InteractionOperationRow = typeof schema.interactionOperations.$inferSelect;
 export declare const MANAGED_BROWSER_SESSION_CAPABILITIES: {
@@ -307,6 +308,7 @@ export declare function dispatchBrowserSessionOperation(db: Database, input: {
         objectKey: string;
         cleanupAfter: Date;
     };
+    deadlineTarget?: BrowserDeadlineCheckpointTarget;
 }): Promise<InteractionLifecycleOperationReceiptValue>;
 /** Pulse one exact dispatched lifecycle operation while its controller mutation
  * is still in flight. This is not viewer or resource activity: it exists only
@@ -363,6 +365,7 @@ export declare function commitBrowserSessionSuspension(db: Database, input: {
     browserSessionId: string;
     controllerGeneration: string;
     artifact: BrowserStateArtifactCommitInput;
+    deadlineTarget?: BrowserDeadlineCheckpointTarget;
 }): Promise<BrowserSessionMutationResponseValue>;
 export declare function clearSuspendedBrowserSessionController(db: Database, input: {
     accountId: string;

package/dist/canonical-human-identities.js

@@ -11,9 +11,9 @@ import {
   getCanonicalHumanIdentityProjection,
   synchronizeCanonicalHumanLoginBindings,
   validateCanonicalHumanSession
-} from "./chunk-73ZUIXCL.js";
-import "./chunk-RTVDWDBS.js";
-import "./chunk-VHPOPKEZ.js";
+} from "./chunk-M3TGZ7B4.js";
+import "./chunk-2X2GKAC4.js";
+import "./chunk-UAR7ZDNG.js";
 import "./chunk-S2TZ3F4L.js";
 import "./chunk-PZ5AY32C.js";
 export {

package/dist/capability-integrations.d.ts

@@ -1,4 +1,4 @@
-import { type IntegrationSource, type McpServerConnectionRef } from "@opengeni/contracts";
+import { type IntegrationSourceInput, type McpServerConnectionRef } from "@opengeni/contracts";
 import { type Database } from "./database.js";
 export type ApiIntegrationProtocol = "openapi" | "graphql";
 export type ApiIntegrationToolSafety = "read" | "write" | "destructive";
@@ -95,6 +95,12 @@ export type InstallApiIntegrationInput = {
     requiredScopes?: string[];
     ownership?: "workspace" | "subject" | "either";
     allowedTools?: string[];
+    /**
+     * Selected write/destructive tools that run without per-call human approval.
+     * Removing an approval requirement is never a permission reduction, so it
+     * always passes installation acquisition (organization policy) again.
+     */
+    autoApprovedTools?: string[];
     facetDefinitions?: readonly ApiIntegrationFacetDefinition[];
     revision: StoredApiIntegrationRevision;
     owner?: ApiIntegrationOwner;
@@ -199,7 +205,7 @@ export declare function getApiIntegrationReconciliationSnapshot(db: Database, in
     accountId: string;
     workspaceId: string;
     subjectId: string;
-    source: IntegrationSource;
+    source: IntegrationSourceInput;
     connectionId?: string;
     instanceKey?: string;
     expectedRevisionId: string;

package/dist/capability-reconciliation.js

@@ -1,7 +1,7 @@
 import {
   withWorkspaceRls
-} from "./chunk-RTVDWDBS.js";
-import "./chunk-VHPOPKEZ.js";
+} from "./chunk-2X2GKAC4.js";
+import "./chunk-UAR7ZDNG.js";
 import "./chunk-S2TZ3F4L.js";
 import "./chunk-PZ5AY32C.js";
 

package/dist/{chunk-WKLDMSSX.js → chunk-25DAVPRJ.js}

@@ -1,7 +1,7 @@
 import {
   nestedPostgresSqlState,
   rawRows
-} from "./chunk-RTVDWDBS.js";
+} from "./chunk-2X2GKAC4.js";
 
 // src/managed-auth-session-sets.ts
 import {
@@ -296,4 +296,4 @@ export {
   reapManagedAuthIsolatedSessions,
   reapExpiredManagedAuthSessionSets
 };
-//# sourceMappingURL=chunk-WKLDMSSX.js.map
+//# sourceMappingURL=chunk-25DAVPRJ.js.map

package/dist/{chunk-RTVDWDBS.js → chunk-2X2GKAC4.js}

@@ -3,7 +3,7 @@ import {
   sessions,
   workspaceSessionActivityRevisions,
   workspaces
-} from "./chunk-VHPOPKEZ.js";
+} from "./chunk-UAR7ZDNG.js";
 import {
   LOSSLESS_CONTENT_WRITER_APPLICATION_NAME
 } from "./chunk-S2TZ3F4L.js";
@@ -756,7 +756,7 @@ async function withWorkspaceSubjectRls(db, workspaceId, subjectId, fn, transacti
     sessionTenancyFence
   );
 }
-async function withWorkspaceSubjectSessionActivityRls(db, workspaceId, subjectId, fn, transactionConfig, fenceMode = "shared") {
+async function withWorkspaceSubjectSessionActivityRls(db, workspaceId, subjectId, fn, transactionConfig, fenceMode = "shared", organizationMembershipFence = false) {
   if (!subjectId.trim()) {
     throw new Error("withWorkspaceSubjectSessionActivityRls: a non-empty subjectId is required");
   }
@@ -769,7 +769,8 @@ async function withWorkspaceSubjectSessionActivityRls(db, workspaceId, subjectId
       return await fn(scopedDb);
     },
     transactionConfig,
-    fenceMode
+    fenceMode,
+    organizationMembershipFence
   );
 }
 async function setSubjectRlsContext(db, subjectId) {
@@ -837,4 +838,4 @@ export {
   withAccountRls,
   dbBindingFor
 };
-//# sourceMappingURL=chunk-RTVDWDBS.js.map
+//# sourceMappingURL=chunk-2X2GKAC4.js.map