@nylorun/runtime 0.15.2-beta → 0.17.0-beta

package/dist/store/postgres/schema.js

@@ -5,9 +5,8 @@
  * "snake_case"`, here, in `db.ts` and in `drizzle.config.ts`).
  *
  * - `nylorun` holds the Tenant's state: the one `tenant` row, the document tables, Action
- *   endpoints, principals, vaults and credentials, signing keys, publishable keys, subject
- *   epochs and usage, settings, the model usage ledger, the model budgets and the Tool Gate's
- *   crossings.
+ *   endpoints, principals, vaults and credentials, signing keys, settings, the model usage
+ *   ledger, the model budgets, the Tool Gate's crossings and file artifacts with their versions.
  * - `nylorun_streams` holds the record (Durable Streams §6): `session_events`,
  *   `session_log_heads` and the relay's `relay_slots`. The relay's publication is custom SQL
  *   (`drizzle/0002_stream_relay.sql`).
@@ -103,10 +102,13 @@ export const sessions = nylorun.table("sessions", {
     ownerExpiresAt: timestamp({ withTimezone: true, mode: "date" }),
     /** The session owner (`ownerUserId`), not the lease column `owner`. */
     ownerUserId: field("->>'ownerUserId'"),
+    /** The sandbox resource the session is attached to (`sandbox: { id }`). */
+    sandboxId: field("->>'sandboxId'"),
 }, (t) => [
     index("sessions_status").on(t.status, t.ownerExpiresAt),
     index("sessions_agent").on(t.agentId),
     index("sessions_owner_user").on(t.ownerUserId),
+    index("sessions_sandbox").on(t.sandboxId),
 ]);
 export const commands = documents("commands");
 export const effects = nylorun.table("effects", {
@@ -157,11 +159,15 @@ export const vaults = nylorun.table("vaults", {
     /** JSON text, or null. */
     metadataJson: text(),
     createdAt: textC().notNull(),
-    scope: text({ enum: ["user", "host"] }).notNull().default("user"),
+    /**
+     * `user`: one person's (owner `ownerUserId`); `installation`: the installation's own,
+     * attachable to any session (owner `installation`); `host`: the model vault, never attached.
+     */
+    scope: text({ enum: ["user", "installation", "host"] }).notNull().default("user"),
 }, (t) => [
     index("vaults_owner").on(t.ownerUserId, t.createdAt, t.id),
     uniqueIndex("vaults_one_host").on(t.scope).where(sql `scope = 'host'`),
-    check("vaults_scope_check", sql `scope IN ('user', 'host')`),
+    check("vaults_scope_check", sql `scope IN ('user', 'installation', 'host')`),
 ]);
 /** A credential of a vault: its binding in the clear, its secret sealed. */
 export const vaultCredentials = nylorun.table("vault_credentials", {
@@ -204,11 +210,48 @@ export const vaultIdempotency = nylorun.table("vault_idempotency", {
     /** JSON text of the original response. */
     response: text().notNull(),
 });
+/**
+ * An MCP OAuth connect between its start and its callback (F9 C2): found by the SHA-256 of its
+ * `state`, used once, for ten minutes. The PKCE verifier and any client secret are sealed under
+ * the vault key (`sealBytes`), which only the keys module holds.
+ */
+export const oauthPending = nylorun.table("oauth_pending", {
+    stateHash: text().primaryKey(),
+    vaultId: text().notNull(),
+    /** The MCP server's name in the agent, the credential's name. */
+    server: text().notNull(),
+    /** The MCP server's URL (normalized): the credential's binding. */
+    url: text().notNull(),
+    tokenEndpoint: text().notNull(),
+    clientId: text().notNull(),
+    /** How the client authenticates at the token endpoint: `none`, `client_secret_basic` or `client_secret_post`. */
+    tokenEndpointAuth: text({ enum: ["none", "client_secret_basic", "client_secret_post"] }).notNull(),
+    /** The RFC 8707 resource indicator sent with the authorization request, if any. */
+    resource: text(),
+    kekId: text().notNull(),
+    /** Sealed; null for a public client. */
+    clientSecret: bytes(),
+    /** Sealed. */
+    codeVerifier: bytes().notNull(),
+    redirectUri: text().notNull(),
+    expiresAt: textC().notNull(),
+    createdAt: textC().notNull(),
+}, (t) => [
+    foreignKey({
+        name: "oauth_pending_vault_id_fkey",
+        columns: [t.vaultId],
+        foreignColumns: [vaults.id],
+    }).onDelete("cascade"),
+    index("oauth_pending_expires").on(t.expiresAt),
+]);
 export const tenantSettings = nylorun.table("tenant_settings", {
     key: text().primaryKey(),
     value: text().notNull(),
 });
-/** The Tenant's signing keys (subject tokens): the private half sealed, the public JWK not. */
+/**
+ * The Tenant's signing keys (delivery tokens, capability links, run and host tokens): the
+ * private half sealed, the public JWK not.
+ */
 export const signingKeys = nylorun.table("signing_keys", {
     id: textC().primaryKey(),
     state: text({ enum: ["standby", "current", "previous", "revoked"] }).notNull(),
@@ -230,28 +273,6 @@ export const signingKeys = nylorun.table("signing_keys", {
     uniqueIndex("signing_keys_one_current").on(t.state).where(sql `state = 'current'`),
     uniqueIndex("signing_keys_one_previous").on(t.state).where(sql `state = 'previous'`),
 ]);
-/** Each subject's revocation epoch. */
-export const subjectEpochs = nylorun.table("subject_epochs", {
-    subject: textC().primaryKey(),
-    epoch: bigint({ mode: "number" }).notNull(),
-    revokedAt: text().notNull(),
-});
-/** Each subject's turn bucket: tokens left and when they were last refilled. */
-export const subjectUsage = nylorun.table("subject_usage", {
-    subject: textC().primaryKey(),
-    turnTokens: doublePrecision().notNull(),
-    refilledAt: text().notNull(),
-});
-/** Publishable keys (Host feature `browser-access`): public by design. */
-export const publishableKeys = nylorun.table("publishable_keys", {
-    id: textC().primaryKey(),
-    key: textC().notNull().unique("publishable_keys_key_key"),
-    name: text().notNull().unique("publishable_keys_name_key"),
-    /** JSON array of allowed origins. */
-    originsJson: text().notNull(),
-    createdAt: text().notNull(),
-    revokedAt: text(),
-});
 /**
  * Action endpoints: where the Runtime delivers each agent's Actions over HTTP, and the health
  * recent deliveries and the last ping report.
@@ -335,8 +356,133 @@ export const toolCrossings = nylorun.table("tool_crossings", {
     /** The gate's answer (`McpAnswer`), once the call ended; null while it runs or once lost. */
     answer: jsonText(),
 }, (t) => [index("tool_crossings_settled").on(t.settledAt)]);
+/**
+ * A sandbox resource (blueprint D39, F7.1): its id, kind, the spec resolved against the
+ * Tenant's limits when it was created, and the developer's labels. Sessions attach to it by id
+ * (the session body's `sandboxId`). Not the `sandboxes` document table, which holds the virtual
+ * backend's compute records, keyed by workspace key.
+ */
+export const sandboxResources = nylorun.table("sandbox_resources", {
+    id: textC().primaryKey(),
+    kind: text({ enum: ["virtual", "pod"] }).notNull(),
+    /** The resolved `SandboxManifest`. */
+    spec: jsonText().notNull(),
+    /** `{ key: value }`, filtered through `nylorun.doc(labels)`. */
+    labels: jsonText().notNull(),
+    createdAt: textC().notNull(),
+    updatedAt: textC().notNull(),
+    // Kind `pod` (F7.2, D34): null for a virtual sandbox. `tenant/sandboxes.ts` and the
+    // `Sandbox` object's reconcile (`sandbox/pods/reconcile.ts`) are the only writers.
+    /** The agent-sandbox Sandbox's name, `sbx-<16 base32>-g<volume_gen>` (`podName`). */
+    k8sName: textC(),
+    /** Bumped by every reset: a new Sandbox on a new volume. */
+    volumeGen: integer().notNull().default(0),
+    /** `running`, `suspended` or `deleted`. */
+    desired: text({ enum: ["running", "suspended", "deleted"] }),
+    /** `creating`, `running`, `suspended`, `expired`, `lost`, `failed` or `deleting`. */
+    observed: text({
+        enum: ["creating", "running", "suspended", "expired", "lost", "failed", "deleting"],
+    }),
+    /** The UID of the pod that last joined. */
+    podUid: text(),
+    /**
+     * Bumped by every join (`host.join`), relaunch, loss and reset: host and egress tokens carry
+     * it (`epc`), and one of an older epoch is refused (egress-gate reads it too).
+     */
+    hostEpoch: integer().notNull().default(0),
+    /** sha256 (hex) of the incarnation's join token; the token itself is never stored. */
+    joinTokenHash: text(),
+    /** Bumped by every change the Runtime asks of the pod: the sandboxes service's `opId`. */
+    rev: integer().notNull().default(0),
+    /** When a turn last ended on it, for the idle timer. */
+    lastActiveAt: timestamp({ withTimezone: true }),
+    /** When its TTL passes (`createdAt + lifecycle.ttl`). */
+    expiresAt: timestamp({ withTimezone: true }),
+    /** When the current incarnation was asked to run, for the ready deadline. */
+    startedAt: timestamp({ withTimezone: true }),
+    /** Why it failed or was lost. */
+    reason: text(),
+    /** An earlier incarnation's Sandbox still to delete (after a reset or a loss). */
+    retiring: textC(),
+    /**
+     * The id the engine keeps on the volume (`/harness/volume-id`), recorded at the first join:
+     * a join with another one means the volume was replaced (its files are gone), so `lost`.
+     */
+    volumeId: text(),
+});
+/**
+ * Artifacts (blueprint D35, F8.1 and F8.2): an id, a name and numbered versions. The bytes are in
+ * the Object store under each version's `blobKey` (a folder's: its manifest); a blob counts only
+ * once its version row commits. `sessionId` is the session the artifact belongs to, or null for
+ * a Tenant-wide one an application made. `latestVersion` is the newest version's number.
+ */
+export const artifacts = nylorun.table("artifacts", {
+    id: textC().primaryKey(),
+    kind: text({ enum: ["file", "folder"] }).notNull(),
+    name: text().notNull(),
+    contentType: text().notNull(),
+    sessionId: textC(),
+    latestVersion: integer().notNull(),
+    /** Labels as JSON text, or null. */
+    labelsJson: text(),
+    createdAt: textC().notNull(),
+    updatedAt: text().notNull(),
+}, (t) => [
+    index("artifacts_session").on(t.sessionId, t.createdAt, t.id),
+    check("artifacts_kind_check", sql `kind IN ('file', 'folder')`),
+]);
+/** The versions of an artifact, immutable once written. */
+export const artifactVersions = nylorun.table("artifact_versions", {
+    artifactId: textC().notNull(),
+    version: integer().notNull(),
+    /** Where the bytes are in the Object store (`BlobStore`). */
+    blobKey: text().notNull(),
+    size: bigint({ mode: "number" }).notNull(),
+    sha256: text().notNull(),
+    contentType: text().notNull(),
+    source: text({ enum: ["upload", "engine", "export"] }).notNull(),
+    createdAt: textC().notNull(),
+}, (t) => [
+    primaryKey({ name: "artifact_versions_pkey", columns: [t.artifactId, t.version] }),
+    foreignKey({
+        name: "artifact_versions_artifact_id_fkey",
+        columns: [t.artifactId],
+        foreignColumns: [artifacts.id],
+    }).onDelete("cascade"),
+]);
+/**
+ * The content-addressed files each folder version references (F8.2), one row per distinct
+ * SHA-256: the index that says which `blobs/sha256/<hex>` objects are still in use, so deleting
+ * a folder removes only the files no other version names, and the Tenant total counts each file
+ * once. The manifest itself stays the source of truth for paths.
+ */
+export const artifactContent = nylorun.table("artifact_content", {
+    artifactId: textC().notNull(),
+    version: integer().notNull(),
+    sha256: textC().notNull(),
+    size: bigint({ mode: "number" }).notNull(),
+}, (t) => [
+    primaryKey({ name: "artifact_content_pkey", columns: [t.artifactId, t.version, t.sha256] }),
+    foreignKey({
+        name: "artifact_content_version_fkey",
+        columns: [t.artifactId, t.version],
+        foreignColumns: [artifactVersions.artifactId, artifactVersions.version],
+    }).onDelete("cascade"),
+    index("artifact_content_sha256").on(t.sha256),
+]);
 // ---------------------------------------------------------------------------
 // nylorun_streams: the record
+/**
+ * Each sandbox's lifecycle stream (`nylorun.sandbox-event/1`), numbered from 0 per sandbox id.
+ * Written only by the record module; not published to the stream relay.
+ */
+export const sandboxEvents = nylorunStreams.table("sandbox_events", {
+    sandboxId: textC().notNull(),
+    seq: bigint({ mode: "number" }).notNull(),
+    type: text().notNull(),
+    body: jsonText().notNull(),
+    committedAt: timestamp({ withTimezone: true, mode: "string" }).notNull().defaultNow(),
+}, (t) => [primaryKey({ name: "sandbox_events_pkey", columns: [t.sandboxId, t.seq] })]);
 /** Each session's log head: the next seq and the basin generation its events go to. */
 export const sessionLogHeads = nylorunStreams.table("session_log_heads", {
     sessionId: textC().primaryKey(),