[codex] Add random sticky rollouts

cli/src/api/channels.ts

@@ -198,7 +198,7 @@ export function findBundleIdByChannelName(supabase: SupabaseClient<Database>, ap
     .from('channels')
     .select(`
       id,
-      version (id, name)
+      version:app_versions!channels_version_fkey(id, name)
     `)
     .eq('app_id', appId)
     .eq('name', name)
@@ -263,7 +263,7 @@ export async function getActiveChannels(
       created_at,
       created_by,
       app_id,
-      version (id, name)
+      version:app_versions!channels_version_fkey(id, name)
     `)
     .eq('app_id', appid)
     .order('created_at', { ascending: false })

cli/src/bundle/upload.ts

@@ -137,7 +137,7 @@ async function verifyCompatibility(supabase: SupabaseType, pm: pmType, options:
 
   const { data: channelData, error: channelError } = await supabase
     .from('channels')
-    .select('disable_auto_update, version ( min_update_version, native_packages )')
+    .select('disable_auto_update, version:app_versions!channels_version_fkey( min_update_version, native_packages )')
     .eq('name', channel)
     .eq('app_id', appid)
     .maybeSingle()
@@ -616,7 +616,7 @@ type LinkedChannelVersion = {
 async function getLinkedBundleOnChannel(supabase: SupabaseType, appid: string, channel: string): Promise<LinkedChannelVersion> {
   const { data, error } = await supabase
     .from('channels')
-    .select('version ( id, name, deleted )')
+    .select('version:app_versions!channels_version_fkey( id, name, deleted )')
     .eq('app_id', appid)
     .eq('name', channel)
 

cli/src/channel/currentBundle.ts

@@ -51,7 +51,7 @@ export async function currentBundleInternal(channel: string, appId: string, opti
 
   const { data: supabaseChannel, error } = await supabase
     .from('channels')
-    .select('version ( name )')
+    .select('version:app_versions!channels_version_fkey( name )')
     .eq('name', channel)
     .eq('app_id', appId)
     .limit(1)

cli/src/channel/set.ts

@@ -50,6 +50,24 @@ export type { OptionsSetChannel } from '../schemas/channel'
 
 const disableAutoUpdatesPossibleOptions = ['major', 'minor', 'metadata', 'patch', 'none']
 
+function assertIntegerInRange(value: number, label: string, min: number, max: number) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < min || value > max)
+    throw new Error(`${label} must be an integer between ${min} and ${max}`)
+}
+
+function assertOptionalIntegerInRange(value: number | null | undefined, label: string, min: number, max: number) {
+  if (value == null)
+    return
+  assertIntegerInRange(value, label, min, max)
+}
+
+function assertOptionalConfidence(value: number | undefined) {
+  if (value == null)
+    return
+  if (!Number.isFinite(value) || value <= 0 || value >= 1)
+    throw new Error('Auto-pause confidence must be a number greater than 0 and less than 1')
+}
+
 export async function setChannelInternal(channel: string, appId: string, options: OptionsSetChannel, silent = false) {
   if (!silent)
     intro('Set channel')
@@ -97,6 +115,25 @@ export async function setChannelInternal(channel: string, appId: string, options
     emulator,
     device,
     prod,
+    rolloutBundle,
+    rolloutPercentage,
+    rolloutPercentageBps,
+    rolloutEnable,
+    rolloutDisable,
+    rolloutPause,
+    rolloutResume,
+    rolloutRollback,
+    rolloutPromote,
+    rolloutCacheTtlSeconds,
+    autoPauseEnabled,
+    autoPauseDisabled,
+    autoPauseWindowMinutes,
+    autoPauseFailureRateBps,
+    autoPauseConfidence,
+    autoPauseMinAttempts,
+    autoPauseMinFailures,
+    autoPauseAction,
+    autoPauseCooldownMinutes,
   } = options
 
   if (latest && bundle) {
@@ -131,6 +168,25 @@ export async function setChannelInternal(channel: string, appId: string, options
     && device == null
     && prod == null
     && disableAutoUpdate == null
+    && rolloutBundle == null
+    && rolloutPercentage == null
+    && rolloutPercentageBps == null
+    && rolloutEnable == null
+    && rolloutDisable == null
+    && rolloutPause == null
+    && rolloutResume == null
+    && rolloutRollback == null
+    && rolloutPromote == null
+    && rolloutCacheTtlSeconds == null
+    && autoPauseEnabled == null
+    && autoPauseDisabled == null
+    && autoPauseWindowMinutes == null
+    && autoPauseFailureRateBps === undefined
+    && autoPauseConfidence == null
+    && autoPauseMinAttempts === undefined
+    && autoPauseMinFailures === undefined
+    && autoPauseAction == null
+    && autoPauseCooldownMinutes == null
   ) {
     if (!silent)
       log.error('Missing argument, you need to provide a option to set')
@@ -147,7 +203,7 @@ export async function setChannelInternal(channel: string, appId: string, options
     version: undefined as any,
   }
 
-  const { error: channelError } = await supabase
+  const { data: existingChannel, error: channelError } = await supabase
     .from('channels')
     .select()
     .eq('app_id', appId)
@@ -164,6 +220,25 @@ export async function setChannelInternal(channel: string, appId: string, options
     ? (extConfig?.config?.plugins?.CapacitorUpdater?.version || getBundleVersion('', options.packageJson))
     : bundle
 
+  async function findRemoteBundle(versionName: string) {
+    const { data, error: vError } = await supabase
+      .from('app_versions')
+      .select()
+      .eq('app_id', appId)
+      .eq('name', versionName)
+      .eq('user_id', userId)
+      .eq('deleted', false)
+      .single()
+
+    if (vError || !data) {
+      if (!silent)
+        log.error(`Cannot find version ${versionName}`)
+      throw new Error(`Cannot find version ${versionName}`)
+    }
+
+    return data
+  }
+
   if (resolvedBundleVersion != null) {
     const { data, error: vError } = await supabase
       .from('app_versions')
@@ -259,6 +334,90 @@ export async function setChannelInternal(channel: string, appId: string, options
     channelPayload.version = data.id
   }
 
+  if (rolloutBundle != null) {
+    const data = await findRemoteBundle(rolloutBundle)
+    channelPayload.rollout_version = data.id
+    if (rolloutEnable == null)
+      channelPayload.rollout_enabled = true
+    if (!silent)
+      log.info(`Set ${appId} channel: ${channel} rollout target to @${rolloutBundle}`)
+  }
+
+  if (rolloutPercentage != null) {
+    if (!Number.isFinite(rolloutPercentage) || rolloutPercentage < 0 || rolloutPercentage > 100)
+      throw new Error('Rollout percentage must be between 0 and 100')
+  }
+  const finalRolloutPercentageBps = rolloutPercentageBps ?? (rolloutPercentage == null ? undefined : Math.round(rolloutPercentage * 100))
+  if (finalRolloutPercentageBps != null) {
+    assertIntegerInRange(finalRolloutPercentageBps, 'Rollout percentage basis points', 0, 10000)
+    channelPayload.rollout_percentage_bps = finalRolloutPercentageBps
+  }
+
+  if (rolloutEnable != null)
+    channelPayload.rollout_enabled = !!rolloutEnable
+  if (rolloutDisable)
+    channelPayload.rollout_enabled = false
+
+  if (rolloutPause) {
+    channelPayload.rollout_paused_at = new Date().toISOString()
+    channelPayload.rollout_pause_reason = 'Paused from CLI'
+  }
+
+  if (rolloutResume) {
+    channelPayload.rollout_paused_at = null
+    channelPayload.rollout_pause_reason = null
+  }
+
+  if (rolloutRollback) {
+    channelPayload.rollout_version = null
+    channelPayload.rollout_enabled = false
+    channelPayload.rollout_percentage_bps = 0
+    channelPayload.rollout_paused_at = null
+    channelPayload.rollout_pause_reason = null
+  }
+
+  if (rolloutPromote) {
+    const rolloutVersion = channelPayload.rollout_version ?? existingChannel?.rollout_version
+    if (!rolloutVersion)
+      throw new Error('Cannot promote rollout without a rollout target')
+    channelPayload.version = rolloutVersion
+    channelPayload.rollout_version = null
+    channelPayload.rollout_enabled = false
+    channelPayload.rollout_percentage_bps = 0
+    channelPayload.rollout_paused_at = null
+    channelPayload.rollout_pause_reason = null
+  }
+
+  assertOptionalIntegerInRange(rolloutCacheTtlSeconds, 'Rollout cache TTL seconds', 60, 31536000)
+  assertOptionalIntegerInRange(autoPauseWindowMinutes, 'Auto-pause window minutes', 1, 10080)
+  assertOptionalIntegerInRange(autoPauseFailureRateBps, 'Auto-pause failure rate basis points', 0, 10000)
+  assertOptionalConfidence(autoPauseConfidence)
+  assertOptionalIntegerInRange(autoPauseMinAttempts, 'Auto-pause minimum attempts', 0, Number.MAX_SAFE_INTEGER)
+  assertOptionalIntegerInRange(autoPauseMinFailures, 'Auto-pause minimum failures', 0, Number.MAX_SAFE_INTEGER)
+  assertOptionalIntegerInRange(autoPauseCooldownMinutes, 'Auto-pause cooldown minutes', 0, 10080)
+
+  if (rolloutCacheTtlSeconds != null)
+    channelPayload.rollout_cache_ttl_seconds = rolloutCacheTtlSeconds
+
+  if (autoPauseEnabled != null)
+    channelPayload.auto_pause_enabled = !!autoPauseEnabled
+  if (autoPauseDisabled)
+    channelPayload.auto_pause_enabled = false
+  if (autoPauseWindowMinutes != null)
+    channelPayload.auto_pause_window_minutes = autoPauseWindowMinutes
+  if (autoPauseFailureRateBps !== undefined)
+    channelPayload.auto_pause_failure_rate_bps = autoPauseFailureRateBps
+  if (autoPauseConfidence != null)
+    channelPayload.auto_pause_confidence = autoPauseConfidence as any
+  if (autoPauseMinAttempts !== undefined)
+    channelPayload.auto_pause_min_attempts = autoPauseMinAttempts
+  if (autoPauseMinFailures !== undefined)
+    channelPayload.auto_pause_min_failures = autoPauseMinFailures
+  if (autoPauseAction != null)
+    channelPayload.auto_pause_action = autoPauseAction
+  if (autoPauseCooldownMinutes != null)
+    channelPayload.auto_pause_cooldown_minutes = autoPauseCooldownMinutes
+
   if (state != null) {
     if (state !== 'normal' && state !== 'default') {
       if (!silent)

cli/src/index.ts

@@ -492,6 +492,25 @@ Example: npx @capgo/cli@latest channel set production com.example.app --bundle 1
   .option('--self-assign', `Allow device to self-assign to this channel`)
   .option('--no-self-assign', `Disable devices to self-assign to this channel`)
   .option('--disable-auto-update <disableAutoUpdate>', `Block updates by type: major, minor, metadata, patch, or none (allows all)`)
+  .option('--rollout-bundle <rolloutBundle>', `Bundle version to release gradually on this channel`)
+  .option('--rollout-percentage <rolloutPercentage>', `Rollout percentage from 0 to 100`, value => Number.parseFloat(value))
+  .option('--rollout-percentage-bps <rolloutPercentageBps>', `Rollout percentage in basis points from 0 to 10000`, value => Number.parseInt(value, 10))
+  .option('--rollout-enable', `Enable the configured rollout`)
+  .option('--rollout-disable', `Disable the configured rollout`)
+  .option('--rollout-pause', `Pause rollout exposure without rolling back selected devices`)
+  .option('--rollout-resume', `Resume a paused rollout`)
+  .option('--rollout-rollback', `Clear rollout state and return devices to stable`)
+  .option('--rollout-promote', `Promote rollout target to stable and clear rollout state`)
+  .option('--rollout-cache-ttl-seconds <rolloutCacheTtlSeconds>', `Cloudflare rollout decision cache TTL in seconds`, value => Number.parseInt(value, 10))
+  .option('--auto-pause-enabled', `Enable rollout auto-pause policy`)
+  .option('--auto-pause-disabled', `Disable rollout auto-pause policy`)
+  .option('--auto-pause-window-minutes <autoPauseWindowMinutes>', `Stats window for rollout auto-pause`, value => Number.parseInt(value, 10))
+  .option('--auto-pause-failure-rate-bps <autoPauseFailureRateBps>', `Failure-rate threshold in basis points`, value => Number.parseInt(value, 10))
+  .option('--auto-pause-confidence <autoPauseConfidence>', `Confidence level between 0 and 1`, value => Number.parseFloat(value))
+  .option('--auto-pause-min-attempts <autoPauseMinAttempts>', `Minimum install plus fail attempts before auto-pause can trigger`, value => Number.parseInt(value, 10))
+  .option('--auto-pause-min-failures <autoPauseMinFailures>', `Minimum failures before auto-pause can trigger`, value => Number.parseInt(value, 10))
+  .option('--auto-pause-action <autoPauseAction>', `Auto-pause action: pause, rollback, or notify`)
+  .option('--auto-pause-cooldown-minutes <autoPauseCooldownMinutes>', `Cooldown before auto-pause can trigger again`, value => Number.parseInt(value, 10))
   .option('--dev', `Allow sending update to development devices`)
   .option('--no-dev', `Disable sending update to development devices`)
   .option('--prod', `Allow sending update to production devices`)

cli/src/mcp/server.ts

@@ -3,7 +3,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { z } from 'zod'
 import pack from '../../package.json'
-import { addAppOptionsSchema, cleanupOptionsSchema, getStatsOptionsSchema, requestBuildOptionsSchema, starAllRepositoriesOptionsSchema, starRepoOptionsSchema, updateAppOptionsSchema, updateChannelOptionsSchema, uploadOptionsSchema } from '../schemas/sdk'
+import { addAppOptionsSchema, cleanupOptionsSchema, getStatsOptionsSchema, requestBuildOptionsSchema, starAllRepositoriesOptionsSchema, starRepoOptionsSchema, updateAppOptionsSchema, updateChannelOptionsBaseSchema, uploadOptionsSchema } from '../schemas/sdk'
 import { CapgoSDK } from '../sdk'
 import { findSavedKey } from '../utils'
 
@@ -334,8 +334,8 @@ export async function startMcpServer(): Promise<void> {
   server.tool(
     'capgo_update_channel',
     'Update channel settings including linked bundle and targeting options',
-    updateChannelOptionsSchema.pick({ appId: true, channelId: true, bundle: true, state: true, downgrade: true, ios: true, android: true, selfAssign: true, disableAutoUpdate: true, dev: true, emulator: true, device: true, prod: true }).shape,
-    async ({ appId, channelId, bundle, state, downgrade, ios, android, selfAssign, disableAutoUpdate, dev, emulator, device, prod }) => {
+    updateChannelOptionsBaseSchema.pick({ appId: true, channelId: true, bundle: true, state: true, downgrade: true, ios: true, android: true, selfAssign: true, disableAutoUpdate: true, dev: true, emulator: true, device: true, prod: true, rolloutBundle: true, rolloutPercentage: true, rolloutPercentageBps: true, rolloutEnable: true, rolloutDisable: true, rolloutPause: true, rolloutResume: true, rolloutRollback: true, rolloutPromote: true, rolloutCacheTtlSeconds: true, autoPauseEnabled: true, autoPauseDisabled: true, autoPauseWindowMinutes: true, autoPauseFailureRateBps: true, autoPauseConfidence: true, autoPauseMinAttempts: true, autoPauseMinFailures: true, autoPauseAction: true, autoPauseCooldownMinutes: true }).shape,
+    async ({ appId, channelId, bundle, state, downgrade, ios, android, selfAssign, disableAutoUpdate, dev, emulator, device, prod, rolloutBundle, rolloutPercentage, rolloutPercentageBps, rolloutEnable, rolloutDisable, rolloutPause, rolloutResume, rolloutRollback, rolloutPromote, rolloutCacheTtlSeconds, autoPauseEnabled, autoPauseDisabled, autoPauseWindowMinutes, autoPauseFailureRateBps, autoPauseConfidence, autoPauseMinAttempts, autoPauseMinFailures, autoPauseAction, autoPauseCooldownMinutes }) => {
       const result = await sdk.updateChannel({
         appId,
         channelId,
@@ -350,6 +350,25 @@ export async function startMcpServer(): Promise<void> {
         emulator,
         device,
         prod,
+        rolloutBundle,
+        rolloutPercentage,
+        rolloutPercentageBps,
+        rolloutEnable,
+        rolloutDisable,
+        rolloutPause,
+        rolloutResume,
+        rolloutRollback,
+        rolloutPromote,
+        rolloutCacheTtlSeconds,
+        autoPauseEnabled,
+        autoPauseDisabled,
+        autoPauseWindowMinutes,
+        autoPauseFailureRateBps,
+        autoPauseConfidence,
+        autoPauseMinAttempts,
+        autoPauseMinFailures,
+        autoPauseAction,
+        autoPauseCooldownMinutes,
       })
       if (!result.success) {
         return formatMcpError(result)

cli/src/schemas/channel.ts

@@ -1,6 +1,21 @@
 import { z } from 'zod'
 import { optionsBaseSchema } from './base'
 
+function rejectConflictingBooleanGroup<T extends Record<string, unknown>>(value: T, ctx: z.RefinementCtx, keys: Array<keyof T>) {
+  const selected = keys.filter(key => value[key] === true)
+  if (selected.length < 2)
+    return
+
+  const first = String(selected[0])
+  for (const key of selected.slice(1)) {
+    const current = String(key)
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: [current],
+      message: `"${first}" and "${current}" cannot be used together`,
+    })
+  }
+}
 // ============================================================================
 // Channel Data Schema
 // ============================================================================
@@ -64,6 +79,29 @@ export const optionsSetChannelSchema = optionsBaseSchema.extend({
   prod: z.boolean().optional(),
   packageJson: z.string().optional(),
   ignoreMetadataCheck: z.boolean().optional(),
+  rolloutBundle: z.string().optional(),
+  rolloutPercentage: z.number().finite().min(0).max(100).optional(),
+  rolloutPercentageBps: z.number().int().min(0).max(10000).optional(),
+  rolloutEnable: z.boolean().optional(),
+  rolloutDisable: z.boolean().optional(),
+  rolloutPause: z.boolean().optional(),
+  rolloutResume: z.boolean().optional(),
+  rolloutRollback: z.boolean().optional(),
+  rolloutPromote: z.boolean().optional(),
+  rolloutCacheTtlSeconds: z.number().int().min(60).max(31536000).optional(),
+  autoPauseEnabled: z.boolean().optional(),
+  autoPauseDisabled: z.boolean().optional(),
+  autoPauseWindowMinutes: z.number().int().min(1).max(10080).optional(),
+  autoPauseFailureRateBps: z.number().int().min(0).max(10000).nullable().optional(),
+  autoPauseConfidence: z.number().finite().gt(0).lt(1).optional(),
+  autoPauseMinAttempts: z.number().int().min(0).nullable().optional(),
+  autoPauseMinFailures: z.number().int().min(0).nullable().optional(),
+  autoPauseAction: z.enum(['pause', 'rollback', 'notify']).optional(),
+  autoPauseCooldownMinutes: z.number().int().min(0).max(10080).optional(),
+}).superRefine((value, ctx) => {
+  rejectConflictingBooleanGroup(value, ctx, ['rolloutEnable', 'rolloutDisable'])
+  rejectConflictingBooleanGroup(value, ctx, ['rolloutPause', 'rolloutResume', 'rolloutRollback', 'rolloutPromote'])
+  rejectConflictingBooleanGroup(value, ctx, ['autoPauseEnabled', 'autoPauseDisabled'])
 })
 
 export type OptionsSetChannel = z.infer<typeof optionsSetChannelSchema>