Sync public snapshot from freebuff-private

Source: CodebuffAI/freebuff-private@85f19d16a054404e9381063c28eb0f8f302cd643

Author: github-actions[bot]

cli/src/utils/sponsored-cli-capability.ts

@@ -5,7 +5,10 @@ import {
   type SponsoredCapabilityReason,
 } from '@codebuff/common/ads/sponsored-capability'
 import { repoFullNameFromRemote } from '@codebuff/common/ads/sponsored-proposal-target'
-import type { SponsoredLocalContainment } from '@codebuff/common/ads/sponsored-local-execution'
+import {
+  sponsoredLocalContainmentIsFloor,
+  type SponsoredLocalContainment,
+} from '@codebuff/common/ads/sponsored-local-execution'
 import { existsSync, readFileSync } from 'fs'
 import { release } from 'node:os'
 import { join } from 'path'
@@ -112,6 +115,11 @@ function execution(
   if (platform !== 'darwin' && platform !== 'linux')
     return 'unsupported_platform'
   const contained = containment(platform)
+  // The Windows floor (COD-642) is Desktop's arm, answered only for win32,
+  // which returned above. A probe that claims it here is not believed, and
+  // the CLI never offers the floor at all.
+  if (sponsoredLocalContainmentIsFloor(contained))
+    return 'containment_probe_failed'
   if (!contained.available)
     return contained.reason === 'bubblewrap-missing'
       ? 'bubblewrap_missing'

common/src/ads/sponsored-capability.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'bun:test'
 import {
   sponsoredCapabilitySchema,
+  sponsoredDesktopExecutionSurfaceForPlatform,
   SUPABASE_FOUNDATION_MODES,
   SUPABASE_FOUNDATION_RUNNABLE_FRAMEWORKS,
   supabaseFoundationCapabilityEligible,
@@ -186,3 +187,18 @@ describe('foundation execution admission', () => {
     }
   })
 })
+
+describe('the Desktop surface a process reports (COD-642)', () => {
+  test('each OS names its own surface, and no other', () => {
+    expect(sponsoredDesktopExecutionSurfaceForPlatform('darwin')).toBe(
+      'desktop_macos',
+    )
+    expect(sponsoredDesktopExecutionSurfaceForPlatform('linux')).toBe(
+      'desktop_linux',
+    )
+    expect(sponsoredDesktopExecutionSurfaceForPlatform('win32')).toBe(
+      'desktop_windows',
+    )
+    expect(sponsoredDesktopExecutionSurfaceForPlatform('freebsd')).toBeNull()
+  })
+})

common/src/ads/sponsored-capability.ts

@@ -15,6 +15,8 @@ export const sponsoredCapabilityReasonSchema = z.enum([
   'unreadable_package_manifest',
   'no_consent_bridge',
   'containment_probe_failed',
+  // COD-642: the sponsored file tools cannot hold this project's volume.
+  'file_layer_unavailable',
 ])
 export const capabilityInspectionSchema = z.discriminatedUnion('status', [
   z.object({ status: z.literal('available') }).strict(),
@@ -67,6 +69,20 @@ export const SPONSORED_DESKTOP_EXECUTION_SURFACES = [
 ] as const satisfies readonly SponsoredExecutionSurface[]
 export type SponsoredDesktopExecutionSurface =
   (typeof SPONSORED_DESKTOP_EXECUTION_SURFACES)[number]
+
+/**
+ * The Desktop execution surface of the OS a Desktop process runs on, or null
+ * for an OS Desktop does not run sponsored work on. What the client reports,
+ * never what it is granted: the server decides whether that surface is served.
+ */
+export function sponsoredDesktopExecutionSurfaceForPlatform(
+  platform: string,
+): SponsoredDesktopExecutionSurface | null {
+  if (platform === 'darwin') return 'desktop_macos'
+  if (platform === 'linux') return 'desktop_linux'
+  if (platform === 'win32') return 'desktop_windows'
+  return null
+}
 export const sponsoredCapabilitySchema = z
   .object({
     schemaVersion: z.literal(2),

common/src/ads/sponsored-compute-contract.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, test } from 'bun:test'
 import {
   SPONSORED_ACCEPT_EXECUTION_SURFACE_PARAM,
+  acceptClientSurfacePairsWithRow,
   readSponsoredComputePolicy,
   sponsoredAcceptSurfaceMatchesRow,
   sponsoredComputeAdmitsCampaign,
@@ -163,4 +164,34 @@ describe('the funded Accept request pairs the client with the row (COD-642)', ()
     // A client that cannot name its own surface matches nothing recorded.
     expect(sponsoredAcceptSurfaceMatchesRow(null, 'desktop_macos')).toBe(false)
   })
+
+  test('the Accept pairing: Windows only ever takes a Windows row, and a Windows row only a Windows client', () => {
+    // One rule, applied by the server route and by Desktop before consent.
+    expect(
+      acceptClientSurfacePairsWithRow('desktop_windows', 'desktop_windows'),
+    ).toBe(true)
+    // Stricter than the plain match: an unrecorded row is never Windows.
+    expect(acceptClientSurfacePairsWithRow('desktop_windows', undefined)).toBe(
+      false,
+    )
+    expect(acceptClientSurfacePairsWithRow('desktop_windows', null)).toBe(false)
+    expect(
+      acceptClientSurfacePairsWithRow('desktop_windows', 'desktop_macos'),
+    ).toBe(false)
+    // A client that sends nothing (older builds, the CLI) keeps its old rows
+    // and never reaches a Windows one.
+    expect(acceptClientSurfacePairsWithRow(undefined, 'desktop_macos')).toBe(
+      true,
+    )
+    expect(acceptClientSurfacePairsWithRow(undefined, undefined)).toBe(true)
+    expect(acceptClientSurfacePairsWithRow(undefined, 'desktop_windows')).toBe(
+      false,
+    )
+    expect(acceptClientSurfacePairsWithRow('desktop_macos', undefined)).toBe(
+      true,
+    )
+    expect(
+      acceptClientSurfacePairsWithRow('desktop_macos', 'desktop_windows'),
+    ).toBe(false)
+  })
 })

common/src/ads/sponsored-compute-contract.ts

@@ -53,6 +53,35 @@ export function sponsoredAcceptSurfaceMatchesRow(
   return clientSurface === rowSurface
 }
 
+/**
+ * The pairing the funded Accept applies, on the server and on Desktop alike
+ * (COD-642). The row's `execution_surface` says which machine the offer was
+ * minted for; `clientExecutionSurface` says which machine is about to run it.
+ *
+ *  - Absent (a client older than the field, and the CLI, which never sends
+ *    it): any row it could accept before COD-642, and NEVER a
+ *    `desktop_windows` row, whose only legitimate client sends it.
+ *  - `desktop_windows`: only a `desktop_windows` row. An unrecorded row is
+ *    never one, so it is refused too.
+ *  - Anything else: exactly the row's own surface when the row recorded one
+ *    ({@link sponsoredAcceptSurfaceMatchesRow}).
+ *
+ * Linux (COD-655) needs no arm of its own: it follows macOS. `desktop_linux`
+ * pairs only with a `desktop_linux` row, a macOS or Windows client is refused
+ * on one, and an absent field is admitted exactly as it is on a macOS row,
+ * since released Linux builds already run sponsored work under bubblewrap.
+ */
+export function acceptClientSurfacePairsWithRow(
+  clientSurface: SponsoredExecutionSurface | null | undefined,
+  rowSurface: string | null | undefined,
+): boolean {
+  const windows = 'desktop_windows' satisfies SponsoredExecutionSurface
+  if (clientSurface === undefined || clientSurface === null)
+    return rowSurface !== windows
+  if (clientSurface === windows && rowSurface !== windows) return false
+  return sponsoredAcceptSurfaceMatchesRow(clientSurface, rowSurface)
+}
+
 /** Public response shape. The bearer belongs in host memory, never a thread. */
 export type SponsoredComputeGrant = Readonly<{
   token: string

common/src/ads/sponsored-consent.test.ts

@@ -6,6 +6,7 @@ import {
   SPONSORED_CONSENT_MAX_NAME_CHARS,
   SPONSORED_CONSENT_NO_NAME,
   SPONSORED_CONSENT_SENTENCE,
+  SPONSORED_CONSENT_WINDOWS_FLOOR_SENTENCE,
   sponsoredConsentName,
   sponsoredConsentSentence,
 } from './sponsored-consent'
@@ -57,6 +58,23 @@ describe('every surface asks the same question', () => {
     expect(read(rel)).toContain(SPONSORED_CONSENT_SENTENCE.trim())
   })
 
+  test.each([
+    ['freebuff-desktop/electron/mcp-consent-bridge.cjs'],
+    ['freebuff-desktop/electron/consent-window.html'],
+  ])('%s carries the same Windows no-sandbox sentence, verbatim (COD-642)', (rel) => {
+    expect(read(rel)).toContain(SPONSORED_CONSENT_WINDOWS_FLOOR_SENTENCE)
+  })
+
+  test('the Windows sentence says the three things, in plain words', () => {
+    expect(SPONSORED_CONSENT_WINDOWS_FLOOR_SENTENCE).toContain('no sandbox')
+    expect(SPONSORED_CONSENT_WINDOWS_FLOOR_SENTENCE).toContain(
+      'your own Windows permissions',
+    )
+    expect(SPONSORED_CONSENT_WINDOWS_FLOOR_SENTENCE).toContain(
+      'hidden from it but not locked away',
+    )
+  })
+
   test('the desktop window says the same thing when it cannot name who is asking', () => {
     expect(read('freebuff-desktop/electron/consent-window.html')).toContain(
       SPONSORED_CONSENT_NO_NAME,

common/src/ads/sponsored-consent.ts

@@ -24,6 +24,15 @@
 export const SPONSORED_CONSENT_SENTENCE =
   ' wants to integrate itself into this project, on its own branch. Nothing is pushed until you review it.'
 
+/**
+ * The second sentence, shown ONLY where the run has no OS sandbox: Windows (COD-642). Plain words
+ * for the three things a user is agreeing to there -- their own permissions, no sandbox, and
+ * credentials that are kept out of the run's way rather than locked away. Product-owned and fixed:
+ * a surface decides from its own platform whether to show it, never from anything it was sent.
+ */
+export const SPONSORED_CONSENT_WINDOWS_FLOOR_SENTENCE =
+  'On Windows there is no sandbox. This task runs with your own Windows permissions, and your credentials are hidden from it but not locked away.'
+
 /**
  * What a surface shows when it cannot name who is asking. Blank is not a legal render: a sentence
  * about nobody asks a human to consent to nothing, so the surfaces refuse instead of asking.