@opengeni/db 4.0.0-canary.0 → 4.0.0-canary.2

package/dist/chunk-N5VXJ4I2.js

@@ -1,589 +0,0 @@
-import {
-  withRlsContext,
-  withSessionActivityRlsContext
-} from "./chunk-UFAMOUWL.js";
-import {
-  sandboxRetainedProcesses,
-  sessionBackgroundCommands,
-  sessionEvents,
-  sessions
-} from "./chunk-QM6YOWHZ.js";
-
-// src/session-background-commands.ts
-import { and, desc, eq, inArray, sql } from "drizzle-orm";
-var SESSION_BACKGROUND_COMMAND_REASON_MAX_BYTES = 512;
-function boundedSessionBackgroundCommandReason(value, label) {
-  const normalized = value.trim();
-  let bounded = "";
-  let bytes = 0;
-  for (const character of normalized) {
-    const characterBytes = Buffer.byteLength(character, "utf8");
-    if (bytes + characterBytes > SESSION_BACKGROUND_COMMAND_REASON_MAX_BYTES) break;
-    bounded += character;
-    bytes += characterBytes;
-  }
-  if (!bounded) throw new Error(`${label} must not be empty`);
-  return bounded;
-}
-function commandPreview(value) {
-  const normalized = value.replace(/\s+/g, " ").trim();
-  return Array.from(normalized).slice(0, 512).join("");
-}
-function mapCommand(row) {
-  return {
-    id: row.id,
-    workspaceId: row.workspaceId,
-    sessionId: row.sessionId,
-    provider: row.provider,
-    state: row.state,
-    commandPreview: row.commandPreview,
-    cancelRequestedAt: row.cancelRequestedAt?.toISOString() ?? null,
-    exitCode: row.exitCode ?? null,
-    settlementReason: row.settlementReason ?? null,
-    startedAt: row.startedAt.toISOString(),
-    settledAt: row.settledAt?.toISOString() ?? null,
-    updatedAt: row.updatedAt.toISOString()
-  };
-}
-async function backgroundCommandActivityForSessions(db, input) {
-  if (input.sessionIds.length === 0) return /* @__PURE__ */ new Map();
-  return await withRlsContext(
-    db,
-    { accountId: input.accountId, workspaceId: input.workspaceId },
-    async (scopedDb) => {
-      const rows = await scopedDb.select({
-        sessionId: sessionBackgroundCommands.sessionId,
-        count: sql`count(*)::int`,
-        stoppingCount: sql`count(*) filter (where ${sessionBackgroundCommands.state} = 'stopping')::int`
-      }).from(sessionBackgroundCommands).where(
-        and(
-          eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
-          inArray(sessionBackgroundCommands.sessionId, input.sessionIds),
-          inArray(sessionBackgroundCommands.state, ["running", "stopping"])
-        )
-      ).groupBy(sessionBackgroundCommands.sessionId);
-      return new Map(
-        rows.map((row) => [
-          row.sessionId,
-          {
-            state: Number(row.stoppingCount) > 0 ? "stopping" : "running",
-            count: Number(row.count)
-          }
-        ])
-      );
-    }
-  );
-}
-async function listSessionBackgroundCommands(db, input) {
-  return await withRlsContext(
-    db,
-    { accountId: input.accountId, workspaceId: input.workspaceId },
-    async (scopedDb) => {
-      const rows = await scopedDb.select().from(sessionBackgroundCommands).where(
-        and(
-          eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
-          eq(sessionBackgroundCommands.sessionId, input.sessionId)
-        )
-      ).orderBy(
-        desc(sessionBackgroundCommands.startedAt),
-        desc(sessionBackgroundCommands.id)
-      ).limit(1e3);
-      return rows.map(mapCommand);
-    }
-  );
-}
-async function insertManagedSessionBackgroundCommandInTransaction(db, input) {
-  const [process] = await db.select({
-    accountId: sandboxRetainedProcesses.accountId,
-    workspaceId: sandboxRetainedProcesses.workspaceId,
-    sessionId: sandboxRetainedProcesses.sessionId,
-    state: sandboxRetainedProcesses.state
-  }).from(sandboxRetainedProcesses).where(eq(sandboxRetainedProcesses.id, input.retainedProcessId)).for("update").limit(1);
-  if (!process || process.accountId !== input.accountId || process.workspaceId !== input.workspaceId || process.sessionId !== input.sessionId || process.state !== "active") {
-    throw new Error("Managed background command requires its exact active retained process");
-  }
-  const [row] = await db.insert(sessionBackgroundCommands).values({
-    id: input.commandId,
-    accountId: input.accountId,
-    workspaceId: input.workspaceId,
-    sessionId: input.sessionId,
-    provider: "managed",
-    state: "running",
-    retainedProcessId: input.retainedProcessId,
-    commandPreview: commandPreview(input.command)
-  }).onConflictDoUpdate({
-    target: sessionBackgroundCommands.retainedProcessId,
-    targetWhere: sql`${sessionBackgroundCommands.retainedProcessId} is not null`,
-    set: { updatedAt: /* @__PURE__ */ new Date() }
-  }).returning();
-  if (!row) throw new Error("Managed background command adoption returned no row");
-  if (row.accountId !== input.accountId || row.workspaceId !== input.workspaceId || row.sessionId !== input.sessionId || row.provider !== "managed" || row.retainedProcessId !== input.retainedProcessId) {
-    throw new Error("Managed background command adoption conflicted with another identity");
-  }
-  return mapCommand(row);
-}
-async function insertConnectedMachineSessionBackgroundCommandInTransaction(db, input) {
-  const [row] = await db.insert(sessionBackgroundCommands).values({
-    id: input.commandId,
-    accountId: input.accountId,
-    workspaceId: input.workspaceId,
-    sessionId: input.sessionId,
-    provider: "connected_machine",
-    state: "running",
-    controlWorkspaceId: input.controlWorkspaceId,
-    enrollmentId: input.enrollmentId,
-    connectionInstanceId: input.connectionInstanceId,
-    opId: input.opId,
-    commandPreview: commandPreview(input.command)
-  }).onConflictDoUpdate({
-    target: [
-      sessionBackgroundCommands.controlWorkspaceId,
-      sessionBackgroundCommands.enrollmentId,
-      sessionBackgroundCommands.connectionInstanceId,
-      sessionBackgroundCommands.opId
-    ],
-    targetWhere: sql`${sessionBackgroundCommands.provider} = 'connected_machine'`,
-    set: { updatedAt: /* @__PURE__ */ new Date() }
-  }).returning();
-  if (!row) throw new Error("Connected Machine background command adoption returned no row");
-  if (row.accountId !== input.accountId || row.workspaceId !== input.workspaceId || row.sessionId !== input.sessionId || row.provider !== "connected_machine" || row.controlWorkspaceId !== input.controlWorkspaceId || row.enrollmentId !== input.enrollmentId || row.connectionInstanceId !== input.connectionInstanceId || row.opId !== input.opId) {
-    throw new Error(
-      "Connected Machine background command adoption conflicted with another identity"
-    );
-  }
-  return mapCommand(row);
-}
-async function claimConnectedMachineSessionBackgroundCommands(db, input) {
-  if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100) {
-    throw new Error("Connected command reconciliation limit must be between 1 and 100");
-  }
-  if (!Number.isSafeInteger(input.claimTtlMs) || input.claimTtlMs < 0 || input.claimTtlMs > 36e5) {
-    throw new Error("Connected command reconciliation claim TTL is invalid");
-  }
-  const rows = await db.execute(sql`
-    select account_id as "accountId",
-      workspace_id as "workspaceId",
-      session_id as "sessionId",
-      command_id as "commandId",
-      claim_id as "claimId",
-      command_state as "commandState",
-      control_workspace_id as "controlWorkspaceId",
-      enrollment_id as "enrollmentId",
-      connection_instance_id as "connectionInstanceId",
-      op_id as "opId",
-      reconcile_attempts as "reconcileAttempts",
-      reconcile_proof_outcome as "reconcileProofOutcome",
-      reconcile_proof_exit_code as "reconcileProofExitCode",
-      reconcile_proof_reason as "reconcileProofReason",
-      reconcile_proof_observed_at as "reconcileProofObservedAt"
-    from opengeni_private.claim_connected_machine_background_commands(
-      ${input.claimId}::uuid, ${input.limit}::integer, ${input.claimTtlMs}::bigint
-    )
-  `);
-  return rows.map((row) => {
-    if (row.commandState !== "running" && row.commandState !== "stopping") {
-      throw new Error(`Connected command claim returned invalid state ${row.commandState}`);
-    }
-    const proof = row.reconcileProofOutcome === null ? null : row.reconcileProofOutcome === "exited" || row.reconcileProofOutcome === "lost" ? {
-      outcome: row.reconcileProofOutcome,
-      exitCode: row.reconcileProofExitCode === null ? null : Number(row.reconcileProofExitCode),
-      reason: row.reconcileProofReason,
-      observedAt: row.reconcileProofObservedAt instanceof Date ? row.reconcileProofObservedAt : new Date(row.reconcileProofObservedAt)
-    } : (() => {
-      throw new Error(
-        `Connected command claim returned invalid proof ${row.reconcileProofOutcome}`
-      );
-    })();
-    return {
-      commandId: row.commandId,
-      accountId: row.accountId,
-      workspaceId: row.workspaceId,
-      sessionId: row.sessionId,
-      claimId: row.claimId,
-      state: row.commandState,
-      controlWorkspaceId: row.controlWorkspaceId,
-      enrollmentId: row.enrollmentId,
-      connectionInstanceId: row.connectionInstanceId,
-      opId: row.opId,
-      reconcileAttempts: Number(row.reconcileAttempts),
-      proof
-    };
-  });
-}
-function connectedClaimIdentityWhere(claim) {
-  return and(
-    eq(sessionBackgroundCommands.id, claim.commandId),
-    eq(sessionBackgroundCommands.accountId, claim.accountId),
-    eq(sessionBackgroundCommands.workspaceId, claim.workspaceId),
-    eq(sessionBackgroundCommands.sessionId, claim.sessionId),
-    eq(sessionBackgroundCommands.provider, "connected_machine"),
-    eq(sessionBackgroundCommands.controlWorkspaceId, claim.controlWorkspaceId),
-    eq(sessionBackgroundCommands.enrollmentId, claim.enrollmentId),
-    eq(sessionBackgroundCommands.connectionInstanceId, claim.connectionInstanceId),
-    eq(sessionBackgroundCommands.opId, claim.opId),
-    eq(sessionBackgroundCommands.reconcileClaimId, claim.claimId),
-    inArray(sessionBackgroundCommands.state, ["running", "stopping"])
-  );
-}
-async function recordConnectedMachineBackgroundCommandProof(db, input) {
-  const reason = boundedSessionBackgroundCommandReason(
-    input.proof.reason,
-    "Connected command proof reason"
-  );
-  if (input.proof.outcome === "exited" && input.proof.exitCode === null) {
-    throw new Error("Connected command exit proof requires an exit code");
-  }
-  if (input.proof.outcome === "lost" && input.proof.exitCode !== null) {
-    throw new Error("Connected command loss proof cannot carry an exit code");
-  }
-  await withRlsContext(
-    db,
-    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
-    async (scopedDb) => {
-      const [current] = await scopedDb.select().from(sessionBackgroundCommands).where(connectedClaimIdentityWhere(input.claim)).for("update").limit(1);
-      if (!current) throw new Error("Connected command proof was fenced by newer lifecycle state");
-      if (current.reconcileProofOutcome !== null) {
-        const observedAt = current.reconcileProofObservedAt?.getTime() ?? null;
-        if (current.reconcileProofOutcome !== input.proof.outcome || current.reconcileProofExitCode !== input.proof.exitCode || current.reconcileProofReason !== reason || observedAt !== input.proof.observedAt.getTime()) {
-          throw new Error("Connected command reconciliation proof conflicts with durable proof");
-        }
-        return;
-      }
-      const rows = await scopedDb.update(sessionBackgroundCommands).set({
-        reconcileProofOutcome: input.proof.outcome,
-        reconcileProofExitCode: input.proof.exitCode,
-        reconcileProofReason: reason,
-        reconcileProofObservedAt: input.proof.observedAt,
-        lastReconcileOutcome: `proof_${input.proof.outcome}`,
-        updatedAt: /* @__PURE__ */ new Date()
-      }).where(connectedClaimIdentityWhere(input.claim)).returning({ id: sessionBackgroundCommands.id });
-      if (rows.length !== 1) {
-        throw new Error("Connected command proof lost its exact claim during checkpoint");
-      }
-    }
-  );
-}
-async function deferConnectedMachineBackgroundCommandReconciliation(db, input) {
-  if (!Number.isSafeInteger(input.retryAfterMs) || input.retryAfterMs < 0) {
-    throw new Error("Connected command reconciliation retry delay is invalid");
-  }
-  const outcome = input.outcome.trim().slice(0, 64);
-  if (!outcome) throw new Error("Connected command reconciliation outcome must not be empty");
-  return await withRlsContext(
-    db,
-    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
-    async (scopedDb) => {
-      const rows = await scopedDb.update(sessionBackgroundCommands).set({
-        reconcileAfter: new Date(Date.now() + input.retryAfterMs),
-        reconcileClaimId: null,
-        reconcileClaimedAt: null,
-        lastReconcileOutcome: outcome,
-        updatedAt: /* @__PURE__ */ new Date()
-      }).where(connectedClaimIdentityWhere(input.claim)).returning({ id: sessionBackgroundCommands.id });
-      return rows.length === 1;
-    }
-  );
-}
-async function settleClaimedConnectedMachineBackgroundCommandWithMutation(db, input, mutateTerminal) {
-  return await withSessionActivityRlsContext(
-    db,
-    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
-    async (tx) => {
-      await mutateTerminal.prepare(tx);
-      const rows = await tx.execute(sql`
-          update ${sessionBackgroundCommands} command set
-            state = command.reconcile_proof_outcome,
-            exit_code = case
-              when command.reconcile_proof_outcome = 'exited'
-                then command.reconcile_proof_exit_code
-              else null
-            end,
-            settlement_reason = command.reconcile_proof_reason,
-            settled_at = command.reconcile_proof_observed_at,
-            reconcile_claim_id = null,
-            reconcile_claimed_at = null,
-            last_reconcile_outcome = 'settled_' || command.reconcile_proof_outcome,
-            updated_at = clock_timestamp()
-          where command.id = ${input.claim.commandId}
-            and command.account_id = ${input.claim.accountId}
-            and command.workspace_id = ${input.claim.workspaceId}
-            and command.session_id = ${input.claim.sessionId}
-            and command.provider = 'connected_machine'
-            and command.control_workspace_id = ${input.claim.controlWorkspaceId}
-            and command.enrollment_id = ${input.claim.enrollmentId}
-            and command.connection_instance_id = ${input.claim.connectionInstanceId}
-            and command.op_id = ${input.claim.opId}
-            and command.reconcile_claim_id = ${input.claim.claimId}
-            and command.state in ('running', 'stopping')
-            and command.reconcile_proof_outcome in ('exited', 'lost')
-            and command.reconcile_proof_observed_at is not null
-          returning command.id
-        `);
-      if (rows.length !== 1) return false;
-      const [row] = await tx.select().from(sessionBackgroundCommands).where(eq(sessionBackgroundCommands.id, input.claim.commandId)).limit(1);
-      if (!row) throw new Error("Settled Connected Machine command disappeared");
-      await mutateTerminal.commit(tx, mapCommand(row));
-      return true;
-    }
-  );
-}
-async function requestSessionBackgroundCommandCancellation(db, input) {
-  return await withRlsContext(
-    db,
-    { accountId: input.accountId, workspaceId: input.workspaceId },
-    async (scopedDb) => await scopedDb.transaction(async (tx) => {
-      const [current] = await tx.select().from(sessionBackgroundCommands).where(
-        and(
-          eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
-          eq(sessionBackgroundCommands.sessionId, input.sessionId),
-          eq(sessionBackgroundCommands.id, input.commandId)
-        )
-      ).for("update").limit(1);
-      if (!current) return { command: null, accepted: false };
-      if (current.state !== "running") {
-        return { command: mapCommand(current), accepted: false };
-      }
-      const [updated] = await tx.update(sessionBackgroundCommands).set({
-        state: "stopping",
-        cancelRequestedAt: /* @__PURE__ */ new Date(),
-        cancelRequestedBy: input.subjectId.slice(0, 1024),
-        reconcileAfter: /* @__PURE__ */ new Date(),
-        reconcileClaimId: null,
-        reconcileClaimedAt: null,
-        updatedAt: /* @__PURE__ */ new Date()
-      }).where(eq(sessionBackgroundCommands.id, current.id)).returning();
-      if (current.retainedProcessId) {
-        await tx.update(sandboxRetainedProcesses).set({ reconcileAfter: /* @__PURE__ */ new Date(), lastReconcileOutcome: "cancel_requested" }).where(
-          and(
-            eq(sandboxRetainedProcesses.id, current.retainedProcessId),
-            eq(sandboxRetainedProcesses.state, "active"),
-            sql`${sandboxRetainedProcesses.reconcileClaimId} is null`
-          )
-        );
-      }
-      return { command: mapCommand(updated), accepted: true };
-    })
-  );
-}
-async function requestSessionBackgroundCommandCancellationsInTransaction(db, input) {
-  const rootSessionIds = [...new Set(input.rootSessionIds)];
-  if (rootSessionIds.length === 0) return 0;
-  const rows = await db.execute(sql`
-    with recursive roots(id) as (
-      values ${sql.join(
-    rootSessionIds.map((sessionId) => sql`(${sessionId}::uuid)`),
-    sql`, `
-  )}
-    ), subtree(id, path, cycle) as (
-      select session.id, array[session.id]::uuid[], false
-      from roots root
-      join ${sessions} session
-        on session.workspace_id = ${input.workspaceId}
-       and session.id = root.id
-      union all
-      select child.id, parent.path || child.id, child.id = any(parent.path)
-      from subtree parent
-      join ${sessions} child
-        on child.workspace_id = ${input.workspaceId}
-       and child.parent_session_id = parent.id
-      where not parent.cycle
-    ), stopped as (
-      update ${sessionBackgroundCommands} command set
-        state = 'stopping',
-        cancel_requested_at = clock_timestamp(),
-        cancel_requested_by = left(${input.subjectId}, 1024),
-        reconcile_after = clock_timestamp(),
-        reconcile_claim_id = null,
-        reconcile_claimed_at = null,
-        updated_at = clock_timestamp()
-      where command.workspace_id = ${input.workspaceId}
-        and command.session_id in (select id from subtree where not cycle)
-        and command.state = 'running'
-      returning command.retained_process_id
-    ), nudged as (
-      update ${sandboxRetainedProcesses} process set
-        reconcile_after = clock_timestamp(),
-        reconcile_claim_id = null,
-        reconcile_claimed_at = null,
-        last_reconcile_outcome = 'cancel_requested'
-      where process.id in (
-        select stopped.retained_process_id
-        from stopped
-        where stopped.retained_process_id is not null
-      )
-        and process.state = 'active'
-      returning process.id
-    )
-    select count(*)::integer as "commandCount" from stopped
-  `);
-  return Number(rows[0]?.commandCount ?? 0);
-}
-async function requestWorkspaceBackgroundCommandCancellationsInTransaction(db, input) {
-  const rows = await db.execute(sql`
-    with stopped as (
-      update ${sessionBackgroundCommands} command set
-        state = 'stopping',
-        cancel_requested_at = clock_timestamp(),
-        cancel_requested_by = left(${input.subjectId}, 1024),
-        reconcile_after = clock_timestamp(),
-        reconcile_claim_id = null,
-        reconcile_claimed_at = null,
-        updated_at = clock_timestamp()
-      where command.workspace_id = ${input.workspaceId}
-        and command.state = 'running'
-      returning command.retained_process_id
-    ), nudged as (
-      update ${sandboxRetainedProcesses} process set
-        reconcile_after = clock_timestamp(),
-        reconcile_claim_id = null,
-        reconcile_claimed_at = null,
-        last_reconcile_outcome = 'cancel_requested'
-      where process.id in (
-        select stopped.retained_process_id
-        from stopped
-        where stopped.retained_process_id is not null
-      )
-        and process.state = 'active'
-      returning process.id
-    )
-    select count(*)::integer as "commandCount" from stopped
-  `);
-  return Number(rows[0]?.commandCount ?? 0);
-}
-async function settleSessionBackgroundCommandForRetainedProcessInTransaction(tx, input, mutateTerminal) {
-  const reason = boundedSessionBackgroundCommandReason(
-    input.reason,
-    "Managed command settlement reason"
-  );
-  await mutateTerminal.prepare(tx);
-  const [updatedRow] = await tx.update(sessionBackgroundCommands).set({
-    state: input.outcome,
-    exitCode: input.outcome === "exited" ? input.exitCode : null,
-    settlementReason: reason,
-    settledAt: /* @__PURE__ */ new Date(),
-    reconcileClaimId: null,
-    reconcileClaimedAt: null,
-    lastReconcileOutcome: `settled_${input.outcome}`,
-    updatedAt: /* @__PURE__ */ new Date()
-  }).where(
-    and(
-      eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
-      eq(sessionBackgroundCommands.sessionId, input.sessionId),
-      eq(sessionBackgroundCommands.retainedProcessId, input.retainedProcessId),
-      inArray(sessionBackgroundCommands.state, ["running", "stopping"])
-    )
-  ).returning();
-  let row = updatedRow;
-  if (!row) {
-    const [current] = await tx.select().from(sessionBackgroundCommands).where(
-      and(
-        eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
-        eq(sessionBackgroundCommands.sessionId, input.sessionId),
-        eq(sessionBackgroundCommands.retainedProcessId, input.retainedProcessId)
-      )
-    ).for("update").limit(1);
-    if (!current) return null;
-    if (current.state !== input.outcome || current.exitCode !== (input.outcome === "exited" ? input.exitCode : null)) {
-      throw new Error("Managed background command terminal state conflicts with process proof");
-    }
-    const [existingEvent] = await tx.select({ id: sessionEvents.id }).from(sessionEvents).where(
-      and(
-        eq(sessionEvents.workspaceId, input.workspaceId),
-        eq(sessionEvents.sessionId, input.sessionId),
-        eq(sessionEvents.type, "session.command.finished"),
-        sql`${sessionEvents.payload} ->> 'commandId' = ${current.id}`
-      )
-    ).limit(1);
-    if (existingEvent) return mapCommand(current);
-    row = current;
-  }
-  const command = mapCommand(row);
-  await mutateTerminal.commit(tx, command);
-  return command;
-}
-async function settleConnectedMachineSessionBackgroundCommandWithMutation(db, input, mutateTerminal) {
-  const reason = boundedSessionBackgroundCommandReason(
-    input.reason,
-    "Connected command settlement reason"
-  );
-  if (input.outcome === "exited" && input.exitCode === null) {
-    throw new Error("Connected command exit settlement requires an exit code");
-  }
-  if (input.outcome === "lost" && input.exitCode !== null) {
-    throw new Error("Connected command loss settlement cannot carry an exit code");
-  }
-  return await withSessionActivityRlsContext(
-    db,
-    { accountId: input.accountId, workspaceId: input.workspaceId },
-    async (tx) => {
-      await mutateTerminal.prepare(tx);
-      const settledAt = /* @__PURE__ */ new Date();
-      const [row] = await tx.update(sessionBackgroundCommands).set({
-        state: input.outcome,
-        exitCode: input.outcome === "exited" ? input.exitCode : null,
-        settlementReason: reason,
-        settledAt,
-        reconcileClaimId: null,
-        reconcileClaimedAt: null,
-        reconcileProofOutcome: input.outcome,
-        reconcileProofExitCode: input.outcome === "exited" ? input.exitCode : null,
-        reconcileProofReason: reason,
-        reconcileProofObservedAt: settledAt,
-        lastReconcileOutcome: `settled_${input.outcome}`,
-        updatedAt: /* @__PURE__ */ new Date()
-      }).where(
-        and(
-          eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
-          eq(sessionBackgroundCommands.sessionId, input.sessionId),
-          eq(sessionBackgroundCommands.id, input.commandId),
-          eq(sessionBackgroundCommands.provider, "connected_machine"),
-          eq(sessionBackgroundCommands.controlWorkspaceId, input.controlWorkspaceId),
-          eq(sessionBackgroundCommands.enrollmentId, input.enrollmentId),
-          eq(sessionBackgroundCommands.connectionInstanceId, input.connectionInstanceId),
-          eq(sessionBackgroundCommands.opId, input.opId),
-          inArray(sessionBackgroundCommands.state, ["running", "stopping"])
-        )
-      ).returning();
-      if (!row) return null;
-      const command = mapCommand(row);
-      await mutateTerminal.commit(tx, command);
-      return command;
-    }
-  );
-}
-async function getSessionBackgroundCommand(db, input) {
-  return await withRlsContext(
-    db,
-    { accountId: input.accountId, workspaceId: input.workspaceId },
-    async (scopedDb) => {
-      const [row] = await scopedDb.select().from(sessionBackgroundCommands).where(
-        and(
-          eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
-          eq(sessionBackgroundCommands.sessionId, input.sessionId),
-          eq(sessionBackgroundCommands.id, input.commandId)
-        )
-      ).limit(1);
-      return row ? mapCommand(row) : null;
-    }
-  );
-}
-
-export {
-  SESSION_BACKGROUND_COMMAND_REASON_MAX_BYTES,
-  boundedSessionBackgroundCommandReason,
-  backgroundCommandActivityForSessions,
-  listSessionBackgroundCommands,
-  insertManagedSessionBackgroundCommandInTransaction,
-  insertConnectedMachineSessionBackgroundCommandInTransaction,
-  claimConnectedMachineSessionBackgroundCommands,
-  recordConnectedMachineBackgroundCommandProof,
-  deferConnectedMachineBackgroundCommandReconciliation,
-  settleClaimedConnectedMachineBackgroundCommandWithMutation,
-  requestSessionBackgroundCommandCancellation,
-  requestSessionBackgroundCommandCancellationsInTransaction,
-  requestWorkspaceBackgroundCommandCancellationsInTransaction,
-  settleSessionBackgroundCommandForRetainedProcessInTransaction,
-  settleConnectedMachineSessionBackgroundCommandWithMutation,
-  getSessionBackgroundCommand
-};
-//# sourceMappingURL=chunk-N5VXJ4I2.js.map