diff --git a/server/src/services/native-runtime/native-provider-pack-admission.test.ts b/server/src/services/native-runtime/native-provider-pack-admission.test.ts index 90a421485f9..da6f2f9a312 100644 --- a/server/src/services/native-runtime/native-provider-pack-admission.test.ts +++ b/server/src/services/native-runtime/native-provider-pack-admission.test.ts @@ -105,6 +105,31 @@ describe("provider pack admission identity", () => { { identity: initial, sourceRunId: initial.runId, ...binding })).resolves.toBe(false); expect(admittedNativeProviderPack(recovered.session, initial)).toBeNull(); }); + it.each([ + ["source_state_pending", {}, { ...verified, state: "pending" }], + ["source_state_unknown", {}, { ...verified, state: "unknown" }], + ["source_state_missing", {}, null], + ["runner_instance_differs", { runnerInstanceId: "other-runner" }, verified], + ["environment_lease_differs", { runnerEnvironmentLeaseId: "other-lease" }, verified], + ["receipt_invalid", { sessionId: "foreign" }, verified], + ] as const)("names the refused check %s without admitting", async (reason, change, state) => { + const source = sessionFixture(); remember(source.session); + const saved = { ...admittedNativeProviderPack(source.session, initial)!, ...change }; + const recovered = sessionFixture(); + const onRefused = vi.fn(); + await expect(rememberRecoveredNativeProviderPack(receiptDb(saved, state), recovered.session, + { identity: initial, sourceRunId: initial.runId, ...binding, onRefused })).resolves.toBe(false); + expect(onRefused).toHaveBeenCalledExactlyOnceWith(reason); + expect(admittedNativeProviderPack(recovered.session, initial)).toBeNull(); + }); + it("reports nothing when the saved admission is reused", async () => { + const source = sessionFixture(); remember(source.session); + const recovered = sessionFixture(); + const onRefused = vi.fn(); + await expect(rememberRecoveredNativeProviderPack(receiptDb(admittedNativeProviderPack(source.session, initial)), recovered.session, + { identity: initial, sourceRunId: initial.runId, ...binding, onRefused })).resolves.toBe(true); + expect(onRefused).not.toHaveBeenCalled(); + }); it("uses only the exact same-run locked pre-invalidation source snapshot", async () => { const source = sessionFixture(); remember(source.session); const saved = admittedNativeProviderPack(source.session, initial)!; diff --git a/server/src/services/native-runtime/native-provider-pack-admission.ts b/server/src/services/native-runtime/native-provider-pack-admission.ts index 9d4ab3e40ba..6de5cd840a9 100644 --- a/server/src/services/native-runtime/native-provider-pack-admission.ts +++ b/server/src/services/native-runtime/native-provider-pack-admission.ts @@ -31,7 +31,11 @@ const admitted = new WeakMap>(); const digest = /^sha256:[a-f0-9]{64}$/; type NativeRunIdentity = ReturnType; -export type NativeProviderPackAdmissionSource = { runId: string; receipt: unknown; state: unknown; artifacts?: unknown }; +export type NativeProviderPackAdmissionRefusal = "session_identity_unavailable" | "session_identity_differs" + | "source_state_pending" | "source_state_unknown" | "source_state_missing" | "receipt_missing" + | "runner_instance_differs" | "environment_lease_differs" | "receipt_invalid"; + +export type NativeProviderPackAdmissionSource ={ runId: string; receipt: unknown; state: unknown; artifacts?: unknown }; export function nativeProviderPackAdmissionPending(admissionEpoch: string) { return { schema: "paperclip.native-provider-pack-admission-state.v1" as const, state: "pending" as const, admissionEpoch }; @@ -83,19 +87,30 @@ export async function rememberRecoveredNativeProviderPack(db: Db, session: Nativ runnerInstanceId: string; environmentLeaseId: string; source?: NativeProviderPackAdmissionSource; + /** Diagnostics only: names the check that refused the saved admission. */ + onRefused?: (reason: NativeProviderPackAdmissionRefusal) => void | Promise; }): Promise { admitted.delete(session); - if (typeof session.identity !== "function") return false; - if (canonicalProviderPackJson(session.identity()) !== canonicalProviderPackJson(input.identity)) return false; + const refuse = async (reason: NativeProviderPackAdmissionRefusal) => { + try { await input.onRefused?.(reason); } catch { /* diagnostics never change admission */ } + return false; + }; + if (typeof session.identity !== "function") return refuse("session_identity_unavailable"); + if (canonicalProviderPackJson(session.identity()) !== canonicalProviderPackJson(input.identity)) return refuse("session_identity_differs"); const source = input.source?.runId === input.sourceRunId ? input.source : (await db.select({ receipt: sql`${heartbeatRuns.runnerProfileJson}->'nativeProviderPackAdmission'`, state: sql`${heartbeatRuns.runnerProfileJson}->'nativeProviderPackAdmissionState'`, }).from(heartbeatRuns).where(and(eq(heartbeatRuns.id, input.sourceRunId), eq(heartbeatRuns.companyId, input.identity.companyId), eq(heartbeatRuns.agentId, input.identity.agentId), eq(heartbeatRuns.runtimeMode, "native"))).limit(1))[0]; - if (!verifiedState(source?.state)) return false; + if (!verifiedState(source?.state)) { + const state = source?.state && typeof source.state === "object" ? (source.state as Record).state : undefined; + return refuse(state === "pending" ? "source_state_pending" : state === "unknown" ? "source_state_unknown" : "source_state_missing"); + } const value = source?.receipt; - if (!value || typeof value !== "object" || Array.isArray(value)) return false; + if (!value || typeof value !== "object" || Array.isArray(value)) return refuse("receipt_missing"); const receipt = value as Record; + if (receipt.runnerInstanceId !== input.runnerInstanceId) return refuse("runner_instance_differs"); + if (receipt.runnerEnvironmentLeaseId !== input.environmentLeaseId) return refuse("environment_lease_differs"); const keys = new Set(["schema", "stage", "authority", "companyId", "agentId", "runId", "sessionId", "runnerInstanceId", "runnerEnvironmentLeaseId", "providerPackDigest", "opencodeProxySha256", "sourceRevision", "inheritedFromRunId"]); if (Object.keys(receipt).some(key => !keys.has(key)) || receipt.schema !== "paperclip.native-provider-pack-admission.v1" @@ -104,7 +119,7 @@ export async function rememberRecoveredNativeProviderPack(db: Db, session: Nativ || receipt.sessionId !== input.identity.sessionId || receipt.runnerInstanceId !== input.runnerInstanceId || receipt.runnerEnvironmentLeaseId !== input.environmentLeaseId || !digest.test(String(receipt.providerPackDigest)) || !digest.test(String(receipt.opencodeProxySha256)) || !/^[a-f0-9]{40}$/.test(String(receipt.sourceRevision)) - || (receipt.inheritedFromRunId !== undefined && (typeof receipt.inheritedFromRunId !== "string" || !receipt.inheritedFromRunId))) return false; + || (receipt.inheritedFromRunId !== undefined && (typeof receipt.inheritedFromRunId !== "string" || !receipt.inheritedFromRunId))) return refuse("receipt_invalid"); return rememberSelection(session, { admittedRunId: String(receipt.inheritedFromRunId ?? receipt.runId), companyId: input.identity.companyId, agentId: input.identity.agentId, sessionId: input.identity.sessionId, runnerInstanceId: input.runnerInstanceId, environmentLeaseId: input.environmentLeaseId, diff --git a/server/src/services/native-runtime/native-session-executor.ts b/server/src/services/native-runtime/native-session-executor.ts index 28028a99062..fd67d8f80b9 100644 --- a/server/src/services/native-runtime/native-session-executor.ts +++ b/server/src/services/native-runtime/native-session-executor.ts @@ -12495,7 +12495,7 @@ async function executePaperclipNativeSessionAttempt( throw new NativeControllerDetachedForRestartError(); } try { - await recordNativeProviderPackAdmission(input.db, { + const admissionVerified = await recordNativeProviderPackAdmission(input.db, { session, admissionEpoch: providerPackAdmissionEpoch, identity: { runId: input.execution.binding.runId, companyId: input.execution.binding.companyId, @@ -12504,6 +12504,10 @@ async function executePaperclipNativeSessionAttempt( claim: { leaseOwner, attempt, controllerGeneration, controllerBootId: controller.bootId }, waitForClaim: runnerdBackend?.providerAdmissionRequired?.() === true, }); + if (!admissionVerified && runnerdBackend?.providerAdmissionRequired?.() === true) { + logger.warn({ runId: input.execution.binding.runId }, "native provider-pack admission was not verified for this session"); + try { await input.onLog?.("stderr", "[paperclip-runner] native provider-pack admission was not verified for this session\n"); } catch {} + } } catch (error) { // Name the database cause (a SQLSTATE only), so a lost // admission is diagnosable from the run log. @@ -18238,7 +18242,11 @@ async function createRunnerdBackendWithinSessionClaim( try { await rememberRecoveredNativeProviderPack(input.db, session, { identity, sourceRunId, runnerInstanceId: effectiveRunnerInstanceId, environmentLeaseId: effectiveEnvironmentLeaseId, - source: input.providerPackAdmissionSource }); + source: input.providerPackAdmissionSource, + onRefused: async reason => { + logger.warn({ runId: input.execution.binding.runId, sourceRunId, reason }, "saved provider-pack admission was not reused"); + await input.onLog?.("stderr", `[paperclip-runner] saved provider-pack admission was not reused (reason=${reason})\n`); + } }); } catch { try { await input.onLog?.("stderr", "[paperclip-runner] prior provider-pack admission receipt is unavailable\n"); } catch {} }