open-managed-agents 0.1.0

package/dist/src/control-plane/sessions/store.js

@@ -0,0 +1,538 @@
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import { DatabaseSync } from "node:sqlite";
+import { invalidRequest } from "../errors.js";
+import { withSqliteTransaction } from "../sqlite-transaction.js";
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS sessions (
+  id             TEXT PRIMARY KEY,
+  workspace_id   TEXT NOT NULL,
+  type           TEXT NOT NULL,
+  agent_id       TEXT NOT NULL,
+  agent_version  INTEGER NOT NULL,
+  environment_id TEXT NOT NULL,
+  vault_ids      TEXT NOT NULL DEFAULT '[]',
+  status         TEXT NOT NULL,
+  title          TEXT,
+  metadata       TEXT NOT NULL,
+  created_at     TEXT NOT NULL,
+  updated_at     TEXT NOT NULL,
+  archived_at    TEXT,
+  usage          TEXT
+);
+CREATE INDEX IF NOT EXISTS sessions_by_workspace ON sessions (workspace_id, id);
+CREATE INDEX IF NOT EXISTS sessions_by_workspace_agent ON sessions (workspace_id, agent_id, id);
+-- Partial index so the /metrics active-sessions gauge scans O(active), not
+-- O(history) (plan 0121 §3.2).
+CREATE INDEX IF NOT EXISTS idx_sessions_live ON sessions (archived_at) WHERE archived_at IS NULL;
+
+CREATE TABLE IF NOT EXISTS session_resources (
+  id          TEXT PRIMARY KEY,
+  workspace_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  type        TEXT NOT NULL,
+  file_id     TEXT NOT NULL,
+  mount_path  TEXT NOT NULL,
+  position    INTEGER NOT NULL,
+  created_at  TEXT NOT NULL,
+  updated_at  TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS session_resources_by_session
+ON session_resources (workspace_id, session_id, id);
+
+CREATE TABLE IF NOT EXISTS session_file_mount_snapshots (
+  workspace_id      TEXT NOT NULL,
+  session_id        TEXT NOT NULL,
+  resource_id       TEXT NOT NULL,
+  file_id           TEXT NOT NULL,
+  mount_path        TEXT NOT NULL,
+  snapshot_file_id  TEXT NOT NULL,
+  sha256            TEXT NOT NULL,
+  size_bytes        INTEGER NOT NULL,
+  kind              TEXT NOT NULL DEFAULT 'upload',
+  skill_snapshot_id TEXT,
+  PRIMARY KEY (workspace_id, session_id, resource_id)
+);
+CREATE TABLE IF NOT EXISTS session_skill_snapshots (
+  workspace_id TEXT NOT NULL,
+  session_id TEXT NOT NULL,
+  skill_snapshot_id TEXT NOT NULL,
+  skill_id TEXT NOT NULL,
+  version TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT NOT NULL,
+  PRIMARY KEY (workspace_id, session_id, skill_snapshot_id)
+);
+CREATE INDEX IF NOT EXISTS session_file_mount_snapshots_by_session
+ON session_file_mount_snapshots (workspace_id, session_id);
+
+CREATE TABLE IF NOT EXISTS pending_internal_snapshot_deletes (
+  workspace_id      TEXT NOT NULL,
+  session_id        TEXT NOT NULL,
+  resource_id       TEXT NOT NULL,
+  file_id           TEXT NOT NULL,
+  mount_path        TEXT NOT NULL,
+  snapshot_file_id  TEXT NOT NULL,
+  sha256            TEXT NOT NULL,
+  size_bytes        INTEGER NOT NULL,
+  kind              TEXT NOT NULL DEFAULT 'upload',
+  skill_snapshot_id TEXT,
+  created_at        TEXT NOT NULL,
+  last_attempt_at   TEXT,
+  attempt_count     INTEGER NOT NULL DEFAULT 0,
+  last_error        TEXT,
+  PRIMARY KEY (workspace_id, session_id, resource_id)
+);
+
+CREATE TABLE IF NOT EXISTS pending_internal_snapshot_create_rollbacks (
+  workspace_id      TEXT NOT NULL,
+  session_id        TEXT NOT NULL,
+  resource_id       TEXT NOT NULL,
+  file_id           TEXT NOT NULL,
+  mount_path        TEXT NOT NULL,
+  snapshot_file_id  TEXT NOT NULL,
+  sha256            TEXT NOT NULL,
+  size_bytes        INTEGER NOT NULL,
+  kind              TEXT NOT NULL DEFAULT 'upload',
+  skill_snapshot_id TEXT,
+  created_at        TEXT NOT NULL,
+  last_attempt_at   TEXT,
+  attempt_count     INTEGER NOT NULL DEFAULT 0,
+  last_error        TEXT,
+  PRIMARY KEY (workspace_id, session_id, resource_id)
+);
+`;
+export class SqliteSessionStore {
+    db;
+    cursorSigningKey = randomBytes(32);
+    insertStmt;
+    insertResourceStmt;
+    insertSnapshotStmt;
+    insertSkillSnapshotStmt;
+    retrieveActiveStmt;
+    countActiveStmt;
+    hasEnvironmentReferenceStmt;
+    countAllActiveStmt;
+    retrieveAnyStmt;
+    archiveStmt;
+    insertPendingSnapshotDeletesStmt;
+    deleteStmt;
+    deleteResourcesStmt;
+    deleteSnapshotsStmt;
+    resourcesBySessionStmt;
+    snapshotsBySessionStmt;
+    skillSnapshotsBySessionStmt;
+    pendingSnapshotDeleteWorkspacesStmt;
+    pendingSnapshotDeletesByWorkspaceStmt;
+    pendingSnapshotDeletesBySessionStmt;
+    recordPendingSnapshotDeleteAttemptStmt;
+    clearPendingSnapshotDeleteStmt;
+    insertPendingSnapshotCreateRollbackStmt;
+    clearPendingSnapshotCreateRollbacksBySessionStmt;
+    pendingSnapshotCreateRollbackWorkspacesStmt;
+    pendingSnapshotCreateRollbacksByWorkspaceStmt;
+    pendingSnapshotCreateRollbacksBySessionStmt;
+    recordPendingSnapshotCreateRollbackAttemptStmt;
+    clearPendingSnapshotCreateRollbackStmt;
+    listStmts = new Map();
+    constructor(db) {
+        this.db = db;
+        this.db.exec(SCHEMA);
+        ensureVaultIdsColumn(this.db);
+        ensureSnapshotColumns(this.db);
+        this.insertStmt = this.db.prepare(`INSERT INTO sessions (
+        id, workspace_id, type, agent_id, agent_version, environment_id,
+        vault_ids, status, title, metadata, created_at, updated_at, archived_at, usage
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        this.insertResourceStmt = this.db.prepare(`INSERT INTO session_resources (
+        id, workspace_id, session_id, type, file_id, mount_path, position, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        this.insertSnapshotStmt = this.db.prepare(`INSERT INTO session_file_mount_snapshots (
+        workspace_id, session_id, resource_id, file_id, mount_path,
+        snapshot_file_id, sha256, size_bytes, kind, skill_snapshot_id
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        this.insertSkillSnapshotStmt = this.db.prepare(`INSERT INTO session_skill_snapshots
+       (workspace_id,session_id,skill_snapshot_id,skill_id,version,name,description)
+       VALUES (?,?,?,?,?,?,?)`);
+        this.retrieveActiveStmt = this.db.prepare(`SELECT * FROM sessions
+       WHERE workspace_id = ? AND id = ? AND archived_at IS NULL`);
+        this.countActiveStmt = this.db.prepare(`SELECT COUNT(*) AS n FROM sessions
+       WHERE workspace_id = ? AND archived_at IS NULL`);
+        this.hasEnvironmentReferenceStmt = this.db.prepare(`SELECT EXISTS(
+        SELECT 1 FROM sessions WHERE workspace_id = ? AND environment_id = ?
+      ) AS exists_value`);
+        this.countAllActiveStmt = this.db.prepare(`SELECT COUNT(*) AS n FROM sessions WHERE archived_at IS NULL`);
+        this.retrieveAnyStmt = this.db.prepare(`SELECT * FROM sessions
+       WHERE workspace_id = ? AND id = ?`);
+        this.archiveStmt = this.db.prepare(`UPDATE sessions
+       SET status = 'terminated', updated_at = ?, archived_at = COALESCE(archived_at, ?)
+       WHERE workspace_id = ? AND id = ?`);
+        this.insertPendingSnapshotDeletesStmt = this.db.prepare(`INSERT OR IGNORE INTO pending_internal_snapshot_deletes (
+        workspace_id, session_id, resource_id, file_id, mount_path,
+        snapshot_file_id, sha256, size_bytes, kind, skill_snapshot_id, created_at
+      )
+      SELECT
+        workspace_id, session_id, resource_id, file_id, mount_path,
+        snapshot_file_id, sha256, size_bytes, kind, skill_snapshot_id, ?
+      FROM session_file_mount_snapshots
+      WHERE workspace_id = ? AND session_id = ?`);
+        this.deleteStmt = this.db.prepare(`DELETE FROM sessions
+       WHERE workspace_id = ? AND id = ?`);
+        this.deleteResourcesStmt = this.db.prepare(`DELETE FROM session_resources
+       WHERE workspace_id = ? AND session_id = ?`);
+        this.deleteSnapshotsStmt = this.db.prepare(`DELETE FROM session_file_mount_snapshots
+       WHERE workspace_id = ? AND session_id = ?`);
+        this.resourcesBySessionStmt = this.db.prepare(`SELECT * FROM session_resources
+       WHERE workspace_id = ? AND session_id = ?
+       ORDER BY position ASC, id ASC`);
+        this.snapshotsBySessionStmt = this.db.prepare(`SELECT * FROM session_file_mount_snapshots
+       WHERE workspace_id = ? AND session_id = ?
+       ORDER BY resource_id ASC`);
+        this.skillSnapshotsBySessionStmt = this.db.prepare(`SELECT * FROM session_skill_snapshots WHERE workspace_id=? AND session_id=? ORDER BY skill_snapshot_id`);
+        this.pendingSnapshotDeleteWorkspacesStmt = this.db.prepare(`SELECT DISTINCT workspace_id
+       FROM pending_internal_snapshot_deletes
+       ORDER BY workspace_id ASC`);
+        this.pendingSnapshotDeletesByWorkspaceStmt = this.db.prepare(`SELECT *
+       FROM pending_internal_snapshot_deletes
+       WHERE workspace_id = ?
+       ORDER BY session_id ASC, resource_id ASC`);
+        this.pendingSnapshotDeletesBySessionStmt = this.db.prepare(`SELECT *
+       FROM pending_internal_snapshot_deletes
+       WHERE workspace_id = ? AND session_id = ?
+       ORDER BY resource_id ASC`);
+        this.recordPendingSnapshotDeleteAttemptStmt = this.db.prepare(`UPDATE pending_internal_snapshot_deletes
+       SET last_attempt_at = ?, attempt_count = attempt_count + 1, last_error = ?
+       WHERE workspace_id = ? AND session_id = ? AND resource_id = ?`);
+        this.clearPendingSnapshotDeleteStmt = this.db.prepare(`DELETE FROM pending_internal_snapshot_deletes
+       WHERE workspace_id = ? AND session_id = ? AND resource_id = ?`);
+        this.insertPendingSnapshotCreateRollbackStmt = this.db.prepare(`INSERT INTO pending_internal_snapshot_create_rollbacks (
+        workspace_id, session_id, resource_id, file_id, mount_path,
+        snapshot_file_id, sha256, size_bytes, kind, skill_snapshot_id, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        this.clearPendingSnapshotCreateRollbacksBySessionStmt = this.db.prepare(`DELETE FROM pending_internal_snapshot_create_rollbacks
+       WHERE workspace_id = ? AND session_id = ?`);
+        this.pendingSnapshotCreateRollbackWorkspacesStmt = this.db.prepare(`SELECT DISTINCT workspace_id
+       FROM pending_internal_snapshot_create_rollbacks
+       ORDER BY workspace_id ASC`);
+        this.pendingSnapshotCreateRollbacksByWorkspaceStmt = this.db.prepare(`SELECT *
+       FROM pending_internal_snapshot_create_rollbacks
+       WHERE workspace_id = ?
+       ORDER BY session_id ASC, resource_id ASC`);
+        this.pendingSnapshotCreateRollbacksBySessionStmt = this.db.prepare(`SELECT *
+       FROM pending_internal_snapshot_create_rollbacks
+       WHERE workspace_id = ? AND session_id = ?
+       ORDER BY resource_id ASC`);
+        this.recordPendingSnapshotCreateRollbackAttemptStmt = this.db.prepare(`UPDATE pending_internal_snapshot_create_rollbacks
+       SET last_attempt_at = ?, attempt_count = attempt_count + 1, last_error = ?
+       WHERE workspace_id = ? AND session_id = ? AND resource_id = ?`);
+        this.clearPendingSnapshotCreateRollbackStmt = this.db.prepare(`DELETE FROM pending_internal_snapshot_create_rollbacks
+       WHERE workspace_id = ? AND session_id = ? AND resource_id = ?`);
+    }
+    static open(path = ":memory:") {
+        return new SqliteSessionStore(new DatabaseSync(path));
+    }
+    create(record) {
+        return this.createInTransaction(record);
+    }
+    createAndCompleteIdempotency(record, idempotency) {
+        return this.createInTransaction(record, idempotency);
+    }
+    createInTransaction(record, idempotency) {
+        const s = record.row;
+        return this.withTransaction(() => {
+            this.insertStmt.run(s.id, s.workspace_id, s.type, s.agent.id, s.agent.version, s.environment_id, JSON.stringify(s.vault_ids ?? []), s.status, s.title, JSON.stringify(s.metadata), s.created_at, s.updated_at, s.archived_at, s.usage);
+            for (const [position, resource] of s.resources.entries()) {
+                this.insertResourceStmt.run(resource.id, s.workspace_id, s.id, resource.type, resource.file_id, resource.mount_path, position, resource.created_at, resource.updated_at);
+            }
+            for (const snapshot of record.snapshots ?? []) {
+                this.insertSnapshotStmt.run(snapshot.workspace_id, snapshot.session_id, snapshot.resource_id, snapshot.file_id, snapshot.mount_path, snapshot.snapshot_file_id, snapshot.sha256, snapshot.size_bytes, snapshot.kind, snapshot.skill_snapshot_id);
+            }
+            for (const skill of record.skillSnapshots ?? []) {
+                this.insertSkillSnapshotStmt.run(skill.workspace_id, skill.session_id, skill.skill_snapshot_id, skill.skill_id, skill.version, skill.name, skill.description);
+            }
+            idempotency?.complete();
+            this.clearPendingSnapshotCreateRollbacksBySessionStmt.run(s.workspace_id, s.id);
+            return s;
+        });
+    }
+    retrieve(workspaceId, sessionId) {
+        const row = this.retrieveActiveStmt.get(workspaceId, sessionId);
+        return row ? this.deserialize(row) : undefined;
+    }
+    countActive(workspaceId) {
+        return this.countActiveStmt.get(workspaceId).n;
+    }
+    hasEnvironmentReference(workspaceId, environmentId) {
+        return this.hasEnvironmentReferenceStmt.get(workspaceId, environmentId).exists_value === 1;
+    }
+    // Unscoped, for the /metrics gauge (0121 C2) — served by idx_sessions_live.
+    countAllActive() {
+        return this.countAllActiveStmt.get().n;
+    }
+    retrieveAny(workspaceId, sessionId) {
+        const row = this.retrieveAnyStmt.get(workspaceId, sessionId);
+        return row ? this.deserialize(row) : undefined;
+    }
+    archive(workspaceId, sessionId, archivedAt) {
+        this.archiveStmt.run(archivedAt, archivedAt, workspaceId, sessionId);
+        return this.retrieveAny(workspaceId, sessionId);
+    }
+    delete(workspaceId, sessionId) {
+        const existing = this.retrieveAny(workspaceId, sessionId);
+        if (!existing)
+            return undefined;
+        const now = new Date().toISOString();
+        return this.withTransaction(() => {
+            this.insertPendingSnapshotDeletesStmt.run(now, workspaceId, sessionId);
+            this.deleteSnapshotsStmt.run(workspaceId, sessionId);
+            this.db.prepare("DELETE FROM session_skill_snapshots WHERE workspace_id=? AND session_id=?").run(workspaceId, sessionId);
+            this.deleteResourcesStmt.run(workspaceId, sessionId);
+            this.deleteStmt.run(workspaceId, sessionId);
+            return existing;
+        });
+    }
+    withTransaction(fn) {
+        return withSqliteTransaction(this.db, fn);
+    }
+    getFileMountSnapshots(workspaceId, sessionId) {
+        return this.snapshotsBySessionStmt.all(workspaceId, sessionId);
+    }
+    getSkillSnapshots(workspaceId, sessionId) {
+        return this.skillSnapshotsBySessionStmt.all(workspaceId, sessionId);
+    }
+    listPendingInternalSnapshotDeleteWorkspaces() {
+        const rows = this.pendingSnapshotDeleteWorkspacesStmt.all();
+        return rows.map((row) => row.workspace_id);
+    }
+    getPendingInternalSnapshotDeletes(workspaceId, sessionId) {
+        const rows = sessionId === undefined
+            ? this.pendingSnapshotDeletesByWorkspaceStmt.all(workspaceId)
+            : this.pendingSnapshotDeletesBySessionStmt.all(workspaceId, sessionId);
+        return rows;
+    }
+    recordPendingInternalSnapshotDeleteAttempt(workspaceId, sessionId, resourceId, attemptedAt, error) {
+        this.recordPendingSnapshotDeleteAttemptStmt.run(attemptedAt, error, workspaceId, sessionId, resourceId);
+    }
+    clearPendingInternalSnapshotDelete(workspaceId, sessionId, resourceId) {
+        this.clearPendingSnapshotDeleteStmt.run(workspaceId, sessionId, resourceId);
+    }
+    recordPendingInternalSnapshotCreateRollback(row, createdAt) {
+        this.insertPendingSnapshotCreateRollbackStmt.run(row.workspace_id, row.session_id, row.resource_id, row.file_id, row.mount_path, row.snapshot_file_id, row.sha256, row.size_bytes, row.kind, row.skill_snapshot_id, createdAt);
+    }
+    listPendingInternalSnapshotCreateRollbackWorkspaces() {
+        const rows = this.pendingSnapshotCreateRollbackWorkspacesStmt.all();
+        return rows.map((row) => row.workspace_id);
+    }
+    getPendingInternalSnapshotCreateRollbacks(workspaceId, sessionId) {
+        const rows = sessionId === undefined
+            ? this.pendingSnapshotCreateRollbacksByWorkspaceStmt.all(workspaceId)
+            : this.pendingSnapshotCreateRollbacksBySessionStmt.all(workspaceId, sessionId);
+        return rows;
+    }
+    recordPendingInternalSnapshotCreateRollbackAttempt(workspaceId, sessionId, resourceId, attemptedAt, error) {
+        this.recordPendingSnapshotCreateRollbackAttemptStmt.run(attemptedAt, error, workspaceId, sessionId, resourceId);
+    }
+    clearPendingInternalSnapshotCreateRollback(workspaceId, sessionId, resourceId) {
+        this.clearPendingSnapshotCreateRollbackStmt.run(workspaceId, sessionId, resourceId);
+    }
+    list(workspaceId, opts = {}) {
+        if (opts.page === "") {
+            return { data: [], next_page: null, prev_page: null };
+        }
+        const limit = normalizeLimit(opts.limit);
+        const order = opts.order ?? "desc";
+        const includeArchived = opts.includeArchived ?? false;
+        const cursor = opts.page === undefined
+            ? undefined
+            : decodeSessionCursor(opts.page, { order, agentId: opts.agentId, includeArchived }, workspaceId, this.cursorSigningKey);
+        const direction = cursor?.direction ?? "next";
+        const queryOrder = direction === "prev"
+            ? (order === "asc" ? "desc" : "asc")
+            : order;
+        const stmt = this.listStmt({
+            includeArchived,
+            hasAgent: opts.agentId !== undefined,
+            hasPage: cursor !== undefined,
+            order: queryOrder,
+        });
+        const rows = stmt.all(...selectListArgs(workspaceId, limit + 1, opts.agentId, cursor?.anchor));
+        const hasMoreInQueryDirection = rows.length > limit;
+        const selected = rows.slice(0, limit);
+        if (direction === "prev")
+            selected.reverse();
+        const data = selected.map((row) => this.deserialize(row));
+        const hasNext = direction === "prev" ? cursor !== undefined : hasMoreInQueryDirection;
+        const hasPrev = direction === "prev" ? hasMoreInQueryDirection : cursor !== undefined;
+        const context = { order, agentId: opts.agentId, includeArchived };
+        return {
+            data,
+            next_page: hasNext && data.length > 0
+                ? encodeSessionCursor(data[data.length - 1].id, "next", context, workspaceId, this.cursorSigningKey)
+                : null,
+            prev_page: hasPrev && data.length > 0
+                ? encodeSessionCursor(data[0].id, "prev", context, workspaceId, this.cursorSigningKey)
+                : null,
+        };
+    }
+    close() {
+        this.db.close();
+    }
+    listStmt(opts) {
+        const key = JSON.stringify(opts);
+        const existing = this.listStmts.get(key);
+        if (existing)
+            return existing;
+        const predicates = ["workspace_id = ?"];
+        if (opts.hasAgent)
+            predicates.push("agent_id = ?");
+        if (!opts.includeArchived)
+            predicates.push("archived_at IS NULL");
+        if (opts.hasPage)
+            predicates.push(opts.order === "asc" ? "id > ?" : "id < ?");
+        const stmt = this.db.prepare(`SELECT * FROM sessions
+       WHERE ${predicates.join(" AND ")}
+       ORDER BY id ${opts.order.toUpperCase()}
+       LIMIT ?`);
+        this.listStmts.set(key, stmt);
+        return stmt;
+    }
+    deserialize(row) {
+        return {
+            id: row.id,
+            workspace_id: row.workspace_id,
+            type: "session",
+            agent: {
+                type: "agent",
+                id: row.agent_id,
+                version: row.agent_version,
+            },
+            environment_id: row.environment_id,
+            vault_ids: parseVaultIds(row.vault_ids),
+            status: row.status,
+            title: row.title,
+            metadata: JSON.parse(row.metadata),
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            archived_at: row.archived_at,
+            // B.1 has no runtime usage source yet; Cycle C/D should deserialize this column.
+            usage: null,
+            resources: this.resourcesBySessionStmt.all(row.workspace_id, row.id),
+        };
+    }
+}
+function ensureVaultIdsColumn(db) {
+    const columns = db.prepare("PRAGMA table_info(sessions)").all();
+    if (columns.some((column) => column.name === "vault_ids"))
+        return;
+    db.exec("ALTER TABLE sessions ADD COLUMN vault_ids TEXT NOT NULL DEFAULT '[]'");
+}
+function ensureSnapshotColumns(db) {
+    for (const table of [
+        "session_file_mount_snapshots",
+        "pending_internal_snapshot_deletes",
+        "pending_internal_snapshot_create_rollbacks",
+    ]) {
+        const columns = db.prepare(`PRAGMA table_info(${table})`).all();
+        if (!columns.some((column) => column.name === "kind")) {
+            db.exec(`ALTER TABLE ${table} ADD COLUMN kind TEXT NOT NULL DEFAULT 'upload'`);
+        }
+        if (!columns.some((column) => column.name === "skill_snapshot_id")) {
+            db.exec(`ALTER TABLE ${table} ADD COLUMN skill_snapshot_id TEXT`);
+        }
+    }
+}
+function parseVaultIds(value) {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) && parsed.every((item) => typeof item === "string")
+        ? [...parsed]
+        : [];
+}
+function encodeSessionCursor(anchor, direction, context, workspaceId, signingKey) {
+    const payload = {
+        v: 1,
+        anchor,
+        direction,
+        order: context.order,
+        agentId: context.agentId ?? null,
+        includeArchived: context.includeArchived,
+    };
+    const encodedPayload = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+    const signature = signSessionCursor(encodedPayload, workspaceId, signingKey);
+    return `${encodedPayload}.${signature.toString("base64url")}`;
+}
+function decodeSessionCursor(value, context, workspaceId, signingKey) {
+    let payload;
+    try {
+        const parts = value.split(".");
+        if (parts.length !== 2)
+            throw new Error("invalid signed cursor");
+        const [encodedPayload, encodedSignature] = parts;
+        const decoded = decodeCanonicalBase64url(encodedPayload);
+        const signature = decodeCanonicalBase64url(encodedSignature);
+        const expected = signSessionCursor(encodedPayload, workspaceId, signingKey);
+        if (signature.length !== expected.length ||
+            !timingSafeEqual(signature, expected)) {
+            throw new Error("invalid cursor signature");
+        }
+        payload = JSON.parse(decoded.toString("utf8"));
+    }
+    catch {
+        throw invalidRequest("invalid page cursor");
+    }
+    if (!isSessionCursorPayload(payload))
+        throw invalidRequest("invalid page cursor");
+    if (payload.order !== context.order) {
+        throw invalidRequest("page token order does not match request");
+    }
+    if (payload.agentId !== (context.agentId ?? null) ||
+        payload.includeArchived !== context.includeArchived) {
+        throw invalidRequest("page token filters do not match request");
+    }
+    return payload;
+}
+function signSessionCursor(encodedPayload, workspaceId, signingKey) {
+    return createHmac("sha256", signingKey)
+        .update("oma-session-page-v1\0", "utf8")
+        .update(workspaceId, "utf8")
+        .update("\0", "utf8")
+        .update(encodedPayload, "utf8")
+        .digest();
+}
+function decodeCanonicalBase64url(value) {
+    if (!/^[A-Za-z0-9_-]+$/.test(value)) {
+        throw new Error("non-canonical base64url");
+    }
+    const decoded = Buffer.from(value, "base64url");
+    if (decoded.toString("base64url") !== value) {
+        throw new Error("non-canonical base64url");
+    }
+    return decoded;
+}
+function isSessionCursorPayload(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const payload = value;
+    return payload.v === 1 &&
+        typeof payload.anchor === "string" && payload.anchor.length > 0 &&
+        (payload.direction === "next" || payload.direction === "prev") &&
+        (payload.order === "asc" || payload.order === "desc") &&
+        (payload.agentId === null || typeof payload.agentId === "string") &&
+        typeof payload.includeArchived === "boolean";
+}
+function selectListArgs(workspaceId, limit, agentId, page) {
+    if (agentId === undefined && page === undefined)
+        return [workspaceId, limit];
+    if (agentId !== undefined && page === undefined) {
+        return [workspaceId, agentId, limit];
+    }
+    if (agentId === undefined && page !== undefined) {
+        return [workspaceId, page, limit];
+    }
+    return [workspaceId, agentId, page, limit];
+}
+function normalizeLimit(limit) {
+    if (limit === undefined)
+        return 20;
+    if (!Number.isSafeInteger(limit) || limit <= 0)
+        return 20;
+    return Math.min(limit, 100);
+}

package/dist/src/control-plane/sessions/types.js

@@ -0,0 +1 @@
+export {};