Merge pull request #255 from nwparker/np4/setup-session

NP-4: cloud setup session (N1), team-first Checkout (N4/O1), desktop one-tab setup
This commit is contained in:
Neil
2026-11-10 06:10:25 -08:00
committed by GitHub
30 changed files with 2319 additions and 33 deletions
@@ -0,0 +1,39 @@
-- Cloud setup sessions (NP-4 N1): one browser trip that chains sign-in, team, plan and GitHub.
-- The desktop creates a session after sign-in and polls it; the setup pages on Orca Cloud auth
-- (auth.onorca.dev/cloud/setup/...) read and advance it; the control plane flips the GitHub step.
-- Times are epoch milliseconds. Additive only.
CREATE TABLE cloud_setup_sessions (
id TEXT PRIMARY KEY,
-- Orca user who created it (billing token `sub`); every page and poll must be that user.
user_id TEXT NOT NULL,
-- 'org:<orgId>' once a team is chosen or created; null until then (setup never bills a user:).
account_id TEXT,
team_name TEXT,
-- 1 when setup created the team (shown as "Rename team" on the done page).
team_created INTEGER NOT NULL DEFAULT 0,
-- https://github.com/<owner>/<repo>, lower-cased, no .git; null when no repository is involved.
repo TEXT,
-- JSON array of the steps the desktop asked for: subset of ["team","plan","github"].
needs TEXT NOT NULL,
-- Label of the device waiting for this session ("MacBook Pro"), shown on the account page.
device TEXT,
-- 'month' | 'year', chosen on the plan page.
billing_interval TEXT,
-- null | 'open' | 'canceled' | 'paid'
checkout_state TEXT,
-- null | 'pending' (owner approval requested on GitHub) | 'done'
github_state TEXT,
-- Latest error for the tracker (X1): timed_out | checkout_canceled | bank_step | trial_unavailable
-- | team_create_failed | wrong_account; cleared when the step moves on.
error_kind TEXT,
error_detail TEXT,
-- One-time browser ticket (SHA-256 hex) that lets the setup pages adopt this session's user.
ticket_hash TEXT,
ticket_expires_at INTEGER,
finished_at INTEGER,
created_at INTEGER NOT NULL,
updated_at INTEGER NOT NULL,
expires_at INTEGER NOT NULL
);
CREATE INDEX cloud_setup_sessions_user ON cloud_setup_sessions(user_id, created_at);
CREATE INDEX cloud_setup_sessions_account_repo ON cloud_setup_sessions(account_id, repo);
+21 -5
View File
@@ -6,6 +6,7 @@ import { BILLING_INTERVALS, PLAN_IDS, priceForPlan, type BillingInterval, type P
import { StripeError, type StripeClient } from './stripe'
import { currentSubscription, customerFor, ensureAccount, linkCustomer } from './store'
import { orgIdOf, type MembershipSource } from './membership'
import { setupCheckoutReturnUrls } from './cloud-setup-urls'
export const MAX_TEAM_SEATS = 500
@@ -13,7 +14,9 @@ export const CheckoutRequestSchema = z
.object({
plan: z.enum(PLAN_IDS),
interval: z.enum(BILLING_INTERVALS).default('month'),
seats: z.number().int().min(1).max(MAX_TEAM_SEATS).default(1)
seats: z.number().int().min(1).max(MAX_TEAM_SEATS).default(1),
// The in-app plans dialog joins an open setup session: Checkout returns to its next step.
setupSessionId: z.string().regex(/^cs_[A-Za-z0-9_-]{22}$/).optional()
})
.strict()
@@ -46,11 +49,17 @@ export async function createCheckout(
caller: BillingCaller,
request: { plan: PlanId; interval: BillingInterval; seats: number },
now: number,
membership: MembershipSource
membership: MembershipSource,
options: { setupSessionId?: string } = {}
): Promise<CheckoutOutcome> {
if (!caller.canManage) {
return { ok: false, status: 403, error: 'billing_admin_required' }
}
// O1/N4: every Checkout lands on a team. A personal account's subscription could never move to
// a team later (the account id is the billing key), so the desktop creates the team first.
if (!caller.accountId.startsWith('org:')) {
return { ok: false, status: 409, error: 'team_required' }
}
const existing = await currentSubscription(env.BILLING_DB, caller.accountId)
if (existing && OPEN_STATUSES.has(existing.status)) {
// Seat and interval changes go through the portal, which prorates; a second subscription
@@ -78,7 +87,13 @@ export async function createCheckout(
throw error
}
}
const metadata = { account_id: caller.accountId, plan: request.plan, interval: request.interval }
const metadata = {
account_id: caller.accountId,
plan: request.plan,
interval: request.interval,
...(options.setupSessionId ? { setup_session_id: options.setupSessionId } : {})
}
const setupReturn = options.setupSessionId ? setupCheckoutReturnUrls(env, options.setupSessionId) : null
const session = await stripe.createCheckoutSession(
{
mode: 'subscription',
@@ -92,8 +107,9 @@ export async function createCheckout(
payment_method_collection: 'always',
allow_promotion_codes: true,
customer_update: { address: 'auto', name: 'auto' },
success_url: returnUrl(env, { checkout: 'success', session_id: 'CHECKOUT_SESSION_ID_PLACEHOLDER' }),
cancel_url: returnUrl(env, { checkout: 'cancel' }),
success_url:
setupReturn?.success ?? returnUrl(env, { checkout: 'success', session_id: 'CHECKOUT_SESSION_ID_PLACEHOLDER' }),
cancel_url: setupReturn?.cancel ?? returnUrl(env, { checkout: 'cancel' }),
metadata,
...(env.STRIPE_AUTOMATIC_TAX === 'true'
? { automatic_tax: { enabled: true }, tax_id_collection: { enabled: true } }
@@ -0,0 +1,31 @@
// The setup session's view of the one-time trial (N11, owned by src/trial.ts). Kept behind this
// port so the setup flow reads one shape whatever the trial module returns.
import type { Env } from './env'
export type SetupTrial = { includedSeconds: number; usedSeconds: number; exhausted: boolean }
export type TrialGrantInput = {
accountId: string
userId: string
email?: string
emailVerified?: boolean
githubUserId?: number
githubOwnerId?: number
ip?: string
}
export type TrialPort = {
/** Sandbox seconds a new team's trial includes, or null when no trial is offered at all. */
offeredSeconds(env: Env): number | null
/** The account's trial, or null when it has none (or a plan ended it). */
current(env: Env, accountId: string, now: number): Promise<SetupTrial | null>
/** Grants the trial if this account and user may still get one. Idempotent. */
grant(env: Env, input: TrialGrantInput, now: number): Promise<{ ok: true; trial: SetupTrial } | { ok: false; reason: string }>
}
/** No trial backend: every team goes through a plan. Replaced by the trial module's port. */
export const noTrialPort: TrialPort = {
offeredSeconds: () => null,
current: async () => null,
grant: async () => ({ ok: false, reason: 'trial_unavailable' })
}
@@ -0,0 +1,22 @@
// URLs of the cloud setup pages on Orca Cloud auth (auth.onorca.dev/cloud/setup/...).
import type { Env } from './env'
function pagesOrigin(env: Env): string {
return (env.CLOUD_SETUP_PAGES_URL ?? 'https://auth.onorca.dev').replace(/\/$/, '')
}
export function setupPageUrl(env: Env, path: string, params: Record<string, string>): string {
const url = new URL(`${pagesOrigin(env)}/cloud/setup${path}`)
for (const [key, value] of Object.entries(params)) {
url.searchParams.set(key, value)
}
return url.toString()
}
/** Checkout return URLs for a setup session: success continues the chain, cancel goes back to T3. */
export function setupCheckoutReturnUrls(env: Env, id: string): { success: string; cancel: string } {
return {
success: setupPageUrl(env, '/next', { session: id, from: 'checkout', checkout: 'success' }),
cancel: setupPageUrl(env, '/plan', { session: id, checkout: 'canceled' })
}
}
+661
View File
@@ -0,0 +1,661 @@
// Cloud setup sessions (NP-4 N1): one browser tab that chains sign-in -> team -> plan/trial ->
// (Checkout only when needed) -> GitHub App install, skipping steps that are already done.
//
// Who talks to it:
// - Desktop (billing JWT): creates a session after sign-in and polls it. The session belongs to
// that Orca user; nobody else can read it.
// - Setup pages on Orca Cloud auth (MEMBERSHIP_SYNC_TOKEN): redeem the one-time browser ticket,
// read the session, bind the team, open Checkout, ask for the GitHub install URL, record errors.
// Auth asserts the browser's user; every call re-checks it against the session's user.
// - Control plane (CONTROL_PLANE_TOKEN): flips the GitHub step when an installation binds.
//
// Steps are derived on every read (entitlement, trial, GitHub state), so the session never caches
// a plan state that billing could contradict.
import { z } from 'zod'
import type { BillingCaller } from './auth'
import { createCheckout, OPEN_STATUSES } from './checkout'
import type { TrialPort } from './cloud-setup-trial'
import { computeEntitlement } from './entitlements'
import type { Env } from './env'
import type { MembershipSource } from './membership'
import { BILLING_INTERVALS, type BillingInterval } from './plans'
import type { StripeClient } from './stripe'
import { currentSubscription } from './store'
import { setupPageUrl } from './cloud-setup-urls'
export const SETUP_SESSION_ID = /^cs_[A-Za-z0-9_-]{22}$/
const ORCA_ID = /^[A-Za-z0-9_.:-]{1,128}$/
export const SETUP_STEPS = ['team', 'plan', 'github'] as const
export type SetupNeed = (typeof SETUP_STEPS)[number]
/** Sessions live two hours; no progress for 15 minutes reads as "Setup didn't finish". */
export const SESSION_TTL_MS = 2 * 3600_000
export const IDLE_TIMEOUT_MS = 15 * 60_000
const TICKET_TTL_MS = 10 * 60_000
/** Per user: enough for retries and several projects, too few to farm sessions. */
const MAX_SESSIONS_PER_HOUR = 20
export const SETUP_ERROR_KINDS = [
'timed_out',
'checkout_canceled',
'bank_step',
'trial_unavailable',
'team_create_failed',
'wrong_account'
] as const
export type SetupErrorKind = (typeof SETUP_ERROR_KINDS)[number]
export type SetupStepState = 'done' | 'needed' | 'active' | 'pending' | 'failed' | 'optional'
export type SetupStep = { id: 'account' | 'team' | 'plan' | 'github'; state: SetupStepState; detail?: string }
export type SetupSessionRow = {
id: string
user_id: string
account_id: string | null
team_name: string | null
team_created: number
repo: string | null
needs: string
device: string | null
billing_interval: string | null
checkout_state: string | null
github_state: string | null
error_kind: string | null
error_detail: string | null
ticket_hash: string | null
ticket_expires_at: number | null
finished_at: number | null
created_at: number
updated_at: number
expires_at: number
}
export type SetupSessionView = {
id: string
steps: SetupStep[]
team: { orgId: string; name: string | null; created: boolean } | null
trial: { includedSeconds: number; usedSeconds: number; exhausted: boolean } | null
/** What the plan step rests on once done. */
plan: 'subscription' | 'trial' | null
repo: string | null
finished: boolean
error: { kind: SetupErrorKind; detail?: string } | null
expiresAt: number
}
/** Normalizes a GitHub repository URL to https://github.com/<owner>/<repo> (lower case). */
export function normalizeRepo(value: string | null | undefined): string | null {
if (!value) {
return null
}
const trimmed = value.trim().replace(/\/+$/, '').replace(/\.git$/i, '')
const match =
/^https:\/\/github\.com\/([A-Za-z0-9-]{1,39})\/([A-Za-z0-9._-]{1,100})$/i.exec(trimmed) ??
/^git@github\.com:([A-Za-z0-9-]{1,39})\/([A-Za-z0-9._-]{1,100})$/i.exec(trimmed)
return match ? `https://github.com/${match[1]}/${match[2]}`.toLowerCase() : null
}
export function repoOwner(repo: string | null): string | null {
return repo ? (/^https:\/\/github\.com\/([^/]+)\//.exec(repo)?.[1] ?? null) : null
}
function base64url(bytes: Uint8Array): string {
let binary = ''
for (const byte of bytes) {
binary += String.fromCharCode(byte)
}
return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
}
function randomToken(bytes: number): string {
return base64url(crypto.getRandomValues(new Uint8Array(bytes)))
}
async function sha256Hex(value: string): Promise<string> {
const bytes = new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode(value)))
return Array.from(bytes, (byte) => byte.toString(16).padStart(2, '0')).join('')
}
export function newSetupSessionId(): string {
// 16 random bytes -> 22 base64url characters.
return `cs_${randomToken(16)}`
}
function parseNeeds(row: SetupSessionRow): Set<SetupNeed> {
try {
const parsed = z.array(z.enum(SETUP_STEPS)).safeParse(JSON.parse(row.needs))
return new Set(parsed.success ? parsed.data : [])
} catch {
return new Set()
}
}
export const CreateSetupSessionSchema = z
.object({
repo: z.string().max(300).optional(),
needs: z.array(z.enum(SETUP_STEPS)).max(3).default(['team', 'plan']),
device: z.string().trim().min(1).max(80).optional(),
// The desktop's active team is the session's team unless it asks to choose ('team' in needs).
useActiveTeam: z.boolean().default(true)
})
.strict()
export type CreateSetupSessionResult =
| { ok: true; id: string; url: string; expiresAt: number }
| { ok: false; status: number; error: string }
export async function createSetupSession(
env: Env,
caller: BillingCaller,
body: z.infer<typeof CreateSetupSessionSchema>,
now: number
): Promise<CreateSetupSessionResult> {
const recent = await env.BILLING_DB.prepare(
'SELECT COUNT(*) AS n FROM cloud_setup_sessions WHERE user_id = ?1 AND created_at > ?2'
)
.bind(caller.userId, now - 3600_000)
.first<{ n: number }>()
if ((recent?.n ?? 0) >= MAX_SESSIONS_PER_HOUR) {
return { ok: false, status: 429, error: 'rate_limited' }
}
const repo = normalizeRepo(body.repo)
if (body.repo && !repo) {
return { ok: false, status: 400, error: 'invalid_repo' }
}
const needs = new Set<SetupNeed>(body.needs)
if (needs.has('github') && !repo) {
needs.delete('github')
}
// O1: setup never puts a plan or a trial on a personal account, so a user: caller always gets a
// team step; an org caller keeps its active team unless it asked to choose.
const orgAccount = caller.accountId.startsWith('org:') ? caller.accountId : null
const keepTeam = orgAccount !== null && body.useActiveTeam && !needs.has('team')
if (!keepTeam) {
needs.add('team')
}
const id = newSetupSessionId()
const ticket = randomToken(32)
const expiresAt = now + SESSION_TTL_MS
await env.BILLING_DB.prepare(
`INSERT INTO cloud_setup_sessions (id, user_id, account_id, repo, needs, device, ticket_hash,
ticket_expires_at, created_at, updated_at, expires_at)
VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?9, ?10)`
)
.bind(
id,
caller.userId,
keepTeam ? orgAccount : null,
repo,
JSON.stringify([...needs]),
body.device ?? null,
await sha256Hex(ticket),
now + TICKET_TTL_MS,
now,
expiresAt
)
.run()
return { ok: true, id, url: setupPageUrl(env, '/start', { session: id, ticket }), expiresAt }
}
/** "Copy setup link": a fresh one-time ticket for another browser (the old one is replaced). */
export async function reissueSetupTicket(
env: Env,
caller: BillingCaller,
id: string,
now: number
): Promise<{ url: string } | null> {
const row = await loadSetupSession(env, id, now)
if (!row || row.user_id !== caller.userId || row.finished_at !== null) {
return null
}
const ticket = randomToken(32)
await touch(env, id, { ticket_hash: await sha256Hex(ticket), ticket_expires_at: now + TICKET_TTL_MS }, now)
return { url: setupPageUrl(env, '/start', { session: id, ticket }) }
}
export async function loadSetupSession(env: Env, id: string, now: number): Promise<SetupSessionRow | null> {
if (!SETUP_SESSION_ID.test(id)) {
return null
}
const row = await env.BILLING_DB.prepare('SELECT * FROM cloud_setup_sessions WHERE id = ?1')
.bind(id)
.first<SetupSessionRow>()
return row && row.expires_at > now ? row : null
}
async function touch(env: Env, id: string, fields: Record<string, string | number | null>, now: number): Promise<void> {
const keys = Object.keys(fields)
const sets = keys.map((key, index) => `${key} = ?${index + 2}`)
await env.BILLING_DB.prepare(
`UPDATE cloud_setup_sessions SET ${[...sets, `updated_at = ?${keys.length + 2}`].join(', ')} WHERE id = ?1`
)
.bind(id, ...keys.map((key) => fields[key] ?? null), now)
.run()
}
/** The account's plan state as setup sees it: a live subscription, a usable trial, or neither. */
async function planState(
env: Env,
trial: TrialPort,
accountId: string,
now: number
): Promise<{ plan: 'subscription' | 'trial' | null; trial: SetupSessionView['trial'] }> {
const subscription = await currentSubscription(env.BILLING_DB, accountId)
if (subscription && OPEN_STATUSES.has(subscription.status)) {
const entitlement = await computeEntitlement(env, accountId, now)
// past_due etc. still count as "has a plan": the composer shows the payment state, not setup.
return { plan: entitlement.plan ? 'subscription' : null, trial: null }
}
const current = await trial.current(env, accountId, now)
return { plan: current && !current.exhausted ? 'trial' : null, trial: current }
}
export async function setupSessionView(
env: Env,
trial: TrialPort,
row: SetupSessionRow,
now: number
): Promise<SetupSessionView> {
const needs = parseNeeds(row)
const plan = row.account_id ? await planState(env, trial, row.account_id, now) : { plan: null, trial: null }
const done = {
team: row.account_id !== null,
plan: plan.plan !== null || !needs.has('plan'),
github: row.github_state === 'done' || !needs.has('github')
}
const steps: SetupStep[] = [{ id: 'account', state: 'done' }]
let activeTaken = false
const push = (id: 'team' | 'plan' | 'github', isDone: boolean, detail?: string) => {
if (id !== 'team' && !needs.has(id) && !isDone) {
return
}
if (isDone) {
steps.push({ id, state: 'done', ...(detail ? { detail } : {}) })
return
}
const state: SetupStepState = activeTaken ? 'pending' : 'active'
activeTaken = true
steps.push({ id, state, ...(detail ? { detail } : {}) })
}
push('team', done.team, row.team_name ?? undefined)
if (needs.has('plan') || plan.plan) {
push('plan', done.plan, plan.plan ?? (row.checkout_state === 'open' ? 'checkout' : undefined))
}
if (needs.has('github')) {
push('github', done.github, row.github_state === 'pending' ? 'requested' : undefined)
}
const finished = steps.every((step) => step.state === 'done')
if (finished && row.finished_at === null) {
await touch(env, row.id, { finished_at: now, error_kind: null, error_detail: null }, now)
}
let error: SetupSessionView['error'] = null
if (!finished) {
if (row.error_kind && (SETUP_ERROR_KINDS as readonly string[]).includes(row.error_kind)) {
error = { kind: row.error_kind as SetupErrorKind, ...(row.error_detail ? { detail: row.error_detail } : {}) }
} else if (now - row.updated_at > IDLE_TIMEOUT_MS && row.github_state !== 'pending') {
// An owner approval on GitHub can take longer; everything else has stalled.
error = { kind: 'timed_out' }
}
}
// A failed step reads as failed in the tracker; the rest keep their state.
if (error && error.kind !== 'timed_out') {
const failing = error.kind === 'team_create_failed' || error.kind === 'wrong_account' ? 'team' : 'plan'
const step = steps.find((candidate) => candidate.id === failing)
if (step && step.state !== 'done') {
step.state = 'failed'
}
}
return {
id: row.id,
steps,
team: row.account_id
? { orgId: row.account_id.slice('org:'.length), name: row.team_name, created: row.team_created === 1 }
: null,
trial: plan.trial,
plan: plan.plan,
repo: row.repo,
finished,
error,
expiresAt: row.expires_at
}
}
// ---- Internal: setup pages on Orca Cloud auth -------------------------------------------------
const UserSchema = z.string().regex(ORCA_ID)
export const RedeemSchema = z.object({ sessionId: z.string().regex(SETUP_SESSION_ID), ticket: z.string().min(20).max(100) }).strict()
/** One-time: the ticket from the desktop's URL becomes the browser's proof of this session's user. */
export async function redeemSetupTicket(
env: Env,
body: z.infer<typeof RedeemSchema>,
now: number
): Promise<{ userId: string } | null> {
const row = await loadSetupSession(env, body.sessionId, now)
if (!row || !row.ticket_hash || (row.ticket_expires_at ?? 0) <= now) {
return null
}
if (row.ticket_hash !== (await sha256Hex(body.ticket))) {
return null
}
// Clear it in the same statement that checks it, so two tabs can't both redeem.
const result = await env.BILLING_DB.prepare(
'UPDATE cloud_setup_sessions SET ticket_hash = NULL, ticket_expires_at = NULL, updated_at = ?3 WHERE id = ?1 AND ticket_hash = ?2'
)
.bind(row.id, row.ticket_hash, now)
.run()
if ((result.meta as { changes?: number }).changes === 0) {
return null
}
return { userId: row.user_id }
}
export const InternalReadSchema = z.object({ userId: UserSchema }).strict()
export type InternalSetupSession = SetupSessionView & {
needs: SetupNeed[]
device: string | null
interval: BillingInterval | null
checkoutState: string | null
githubState: string | null
/** For the plan page: whether this team can still get its trial (granted when the team binds). */
ownerHint: string | null
}
export async function readSetupSessionForPages(
env: Env,
trial: TrialPort,
id: string,
userId: string,
now: number
): Promise<InternalSetupSession | null> {
const row = await loadSetupSession(env, id, now)
if (!row || row.user_id !== userId) {
return null
}
const view = await setupSessionView(env, trial, row, now)
return {
...view,
needs: [...parseNeeds(row)],
device: row.device,
interval: (BILLING_INTERVALS as readonly string[]).includes(row.billing_interval ?? '')
? (row.billing_interval as BillingInterval)
: null,
checkoutState: row.checkout_state,
githubState: row.github_state,
ownerHint: repoOwner(row.repo)
}
}
export const TeamPlansSchema = z
.object({ userId: UserSchema, orgIds: z.array(z.string().regex(ORCA_ID)).max(50) })
.strict()
/** A3: which of the user's teams already have a plan or a usable trial (that team is preselected). */
export async function setupTeamPlans(
env: Env,
trial: TrialPort,
id: string,
body: z.infer<typeof TeamPlansSchema>,
now: number
): Promise<Record<string, 'subscription' | 'trial' | 'trial_used_up' | null> | null> {
const row = await loadSetupSession(env, id, now)
if (!row || row.user_id !== body.userId) {
return null
}
const entries = await Promise.all(
body.orgIds.map(async (orgId) => {
const state = await planState(env, trial, `org:${orgId}`, now)
return [orgId, state.plan ?? (state.trial?.exhausted ? 'trial_used_up' : null)] as const
})
)
return Object.fromEntries(entries)
}
export const BindTeamSchema = z
.object({
userId: UserSchema,
orgId: z.string().regex(ORCA_ID),
name: z.string().trim().min(1).max(120),
created: z.boolean().default(false),
// Trial abuse keys (N11), forwarded from the page's request and the user's identity.
email: z.string().email().max(320).optional(),
emailVerified: z.boolean().optional(),
githubUserId: z.number().int().positive().optional(),
githubOwnerId: z.number().int().positive().optional(),
ip: z.string().max(64).optional()
})
.strict()
/**
* Binds the session to a team (chosen, created, or renamed). A team that has no plan gets the
* trial now if it can; otherwise the plan step stays and the pages offer T3 + Checkout.
*/
export async function bindSetupTeam(
env: Env,
trial: TrialPort,
id: string,
body: z.infer<typeof BindTeamSchema>,
now: number
): Promise<{ ok: true; trial: 'granted' | 'unavailable' | 'not_needed' } | { ok: false; status: number; error: string }> {
const row = await loadSetupSession(env, id, now)
if (!row || row.user_id !== body.userId) {
return { ok: false, status: 404, error: 'not_found' }
}
const accountId = `org:${body.orgId}`
// Once bound, only a rename of the same team is accepted; a different team needs a new session.
if (row.account_id && row.account_id !== accountId) {
return { ok: false, status: 409, error: 'team_already_chosen' }
}
await touch(
env,
id,
{
account_id: accountId,
team_name: body.name,
team_created: body.created || row.team_created === 1 ? 1 : 0,
error_kind: null,
error_detail: null
},
now
)
const state = await planState(env, trial, accountId, now)
if (state.plan !== null || !parseNeeds(row).has('plan')) {
return { ok: true, trial: 'not_needed' }
}
if (state.trial) {
// Had a trial and used it up: Checkout.
return { ok: true, trial: 'unavailable' }
}
const granted = await trial.grant(
env,
{
accountId,
userId: body.userId,
...(body.email ? { email: body.email } : {}),
...(body.emailVerified !== undefined ? { emailVerified: body.emailVerified } : {}),
...(body.githubUserId ? { githubUserId: body.githubUserId } : {}),
...(body.githubOwnerId ? { githubOwnerId: body.githubOwnerId } : {}),
...(body.ip ? { ip: body.ip } : {})
},
now
)
return { ok: true, trial: granted.ok ? 'granted' : 'unavailable' }
}
export const SetupErrorSchema = z
.object({
userId: UserSchema,
kind: z.enum(SETUP_ERROR_KINDS).nullable(),
detail: z.string().max(320).optional()
})
.strict()
export async function recordSetupError(
env: Env,
id: string,
body: z.infer<typeof SetupErrorSchema>,
now: number
): Promise<boolean> {
const row = await loadSetupSession(env, id, now)
if (!row || row.user_id !== body.userId) {
return false
}
await touch(
env,
id,
{
error_kind: body.kind,
error_detail: body.kind ? (body.detail ?? null) : null,
...(body.kind === 'checkout_canceled' ? { checkout_state: 'canceled' } : {})
},
now
)
return true
}
export const SetupCheckoutSchema = z
.object({
userId: UserSchema,
orgRole: z.enum(['owner', 'admin', 'member']),
email: z.string().email().max(320).optional(),
interval: z.enum(BILLING_INTERVALS)
})
.strict()
/** T3 -> Stripe: Checkout for the session's team, returning to the setup pages (never a user:). */
export async function createSetupCheckout(
env: Env,
stripe: StripeClient,
id: string,
body: z.infer<typeof SetupCheckoutSchema>,
now: number,
membership: MembershipSource
): Promise<{ ok: true; url: string } | { ok: false; status: number; error: string }> {
const row = await loadSetupSession(env, id, now)
if (!row || row.user_id !== body.userId) {
return { ok: false, status: 404, error: 'not_found' }
}
if (!row.account_id) {
return { ok: false, status: 409, error: 'team_required' }
}
const caller: BillingCaller = {
userId: body.userId,
accountId: row.account_id,
canManage: body.orgRole === 'owner' || body.orgRole === 'admin',
...(body.email ? { email: body.email } : {})
}
const outcome = await createCheckout(
env,
stripe,
caller,
{ plan: 'team', interval: body.interval, seats: 1 },
now,
membership,
{ setupSessionId: id }
)
if (outcome.ok) {
await touch(env, id, { billing_interval: body.interval, checkout_state: 'open', error_kind: null, error_detail: null }, now)
}
return outcome
}
export const GithubInstallSchema = z
.object({
userId: UserSchema,
// Set only after auth verified a live GitHub sign-in token for this user (N5).
githubUserId: z.number().int().positive().optional(),
githubLogin: z.string().regex(/^[A-Za-z0-9-]{1,39}$/).optional()
})
.strict()
const InstallUrlResponse = z.looseObject({
access: z.enum(['public', 'granted', 'missing', 'requested']),
url: z.string().url().nullable().optional()
})
/** Asks the control plane how this session's repository is reachable and, if not, for the install URL. */
export async function setupGithubInstall(
env: Env,
id: string,
body: z.infer<typeof GithubInstallSchema>,
now: number,
fetchImpl: typeof fetch = fetch
): Promise<{ ok: true; access: string; url: string | null } | { ok: false; status: number; error: string }> {
const row = await loadSetupSession(env, id, now)
if (!row || row.user_id !== body.userId) {
return { ok: false, status: 404, error: 'not_found' }
}
if (!row.repo || !row.account_id) {
return { ok: false, status: 409, error: row.repo ? 'team_required' : 'no_repo' }
}
if (!env.SANDBOX_CONTROL_URL) {
return { ok: false, status: 503, error: 'github_unavailable' }
}
const url = new URL('/v1/internal/github/install-url', env.SANDBOX_CONTROL_URL)
url.searchParams.set('accountId', row.account_id)
url.searchParams.set('userId', row.user_id)
url.searchParams.set('repo', row.repo)
url.searchParams.set('session', row.id)
if (body.githubUserId && body.githubLogin) {
url.searchParams.set('githubUserId', String(body.githubUserId))
url.searchParams.set('githubLogin', body.githubLogin)
}
const token = (env.CONTROL_PLANE_TOKEN ?? '').split(',')[0]?.trim() ?? ''
const response = await fetchImpl(url, {
headers: { authorization: `Bearer ${token}`, accept: 'application/json' },
signal: AbortSignal.timeout(8000)
})
const parsed = InstallUrlResponse.safeParse(await response.json().catch(() => null))
if (!response.ok || !parsed.success) {
return { ok: false, status: 502, error: 'github_unavailable' }
}
const access = parsed.data.access
if (access === 'public' || access === 'granted') {
await touch(env, id, { github_state: 'done' }, now)
} else if (access === 'requested') {
await touch(env, id, { github_state: 'pending' }, now)
}
return { ok: true, access, url: access === 'missing' ? (parsed.data.url ?? null) : null }
}
// ---- Internal: control plane ------------------------------------------------------------------
export const GithubEventSchema = z
.object({
sessionId: z.string().regex(SETUP_SESSION_ID).optional(),
accountId: z.string().regex(ORCA_ID),
repo: z.string().max(300),
state: z.enum(['done', 'pending'])
})
.strict()
/** An installation bound (or an owner approval was requested): flip matching open sessions. */
export async function recordGithubEvent(
env: Env,
body: z.infer<typeof GithubEventSchema>,
now: number
): Promise<{ matched: number }> {
const repo = normalizeRepo(body.repo)
if (!repo) {
return { matched: 0 }
}
// 'pending' never overwrites 'done' (a late request echo after the bind).
const guard = body.state === 'pending' ? "AND (github_state IS NULL OR github_state <> 'done')" : ''
const result = body.sessionId
? await env.BILLING_DB.prepare(
`UPDATE cloud_setup_sessions SET github_state = ?1, updated_at = ?2
WHERE id = ?3 AND account_id = ?4 AND repo = ?5 AND expires_at > ?2 ${guard}`
)
.bind(body.state, now, body.sessionId, body.accountId, repo)
.run()
: await env.BILLING_DB.prepare(
`UPDATE cloud_setup_sessions SET github_state = ?1, updated_at = ?2
WHERE account_id = ?3 AND repo = ?4 AND expires_at > ?2 AND finished_at IS NULL ${guard}`
)
.bind(body.state, now, body.accountId, repo)
.run()
return { matched: (result.meta as { changes?: number }).changes ?? 0 }
}
+6
View File
@@ -61,4 +61,10 @@ export type Env = {
// Auth origin serving POST /v1/internal/billing/org-members. Unset: seats come from pushes and the
// Checkout request only (local dev).
AUTH_INTERNAL_URL?: string
// Cloud setup sessions (cloud-setup.ts). Origin of the setup pages on Orca Cloud auth
// (https://auth.onorca.dev, staging https://auth-staging.onorca.dev); Checkout returns there.
CLOUD_SETUP_PAGES_URL?: string
// Control plane origin billing asks for a repository's GitHub install URL (CONTROL_PLANE_TOKEN).
SANDBOX_CONTROL_URL?: string
}
+201 -2
View File
@@ -14,6 +14,20 @@
// GET /v1/internal/suspensions accounts whose payment grace expired (suspend running)
// Orca Cloud auth (MEMBERSHIP_SYNC_TOKEN):
// POST /v1/internal/seats {accountId, members}
// POST /v1/internal/cloud-setup/redeem {sessionId, ticket} -> {userId} one-time browser ticket
// GET /v1/internal/cloud-setup/sessions/:id?userId= session for the pages
// POST /v1/internal/cloud-setup/sessions/:id/team {userId, orgId, name, created, ...abuse keys}
// POST /v1/internal/cloud-setup/sessions/:id/team-plans {userId, orgIds[]} -> {plans}
// POST /v1/internal/cloud-setup/sessions/:id/checkout {userId, orgRole, email?, interval} -> {url}
// POST /v1/internal/cloud-setup/sessions/:id/github {userId, githubUserId?, githubLogin?}
// POST /v1/internal/cloud-setup/sessions/:id/error {userId, kind|null, detail?}
// Cloud setup (desktop billing JWT):
// POST /v1/cloud-setup/sessions {repo?, needs[], device?, useActiveTeam?} -> {id, url, expiresAt}
// GET /v1/cloud-setup/sessions/:id steps, team, trial, finished, error
// POST /v1/cloud-setup/sessions/:id/link -> {url} fresh one-time link ("Copy setup link")
// GET /v1/cloud-setup/offers public: trial hours and Team prices for the setup pages
// Control plane (CONTROL_PLANE_TOKEN):
// POST /v1/internal/cloud-setup/github {sessionId?, accountId, repo, state}
import { z } from 'zod'
import {
ADMIN_ACTION_MAX_TOKEN_AGE,
@@ -35,6 +49,30 @@ import { LiveModeRefusedError, StripeError, createStripeClient, type StripeClien
import { UsageReportSchema, flushMeterReports, recordUsage, validateSegment } from './usage'
import { handleStripeWebhook } from './webhook'
import { renderReturnPage, returnOutcome } from './return-page'
import {
BindTeamSchema,
CreateSetupSessionSchema,
GithubEventSchema,
GithubInstallSchema,
InternalReadSchema,
RedeemSchema,
SetupCheckoutSchema,
SetupErrorSchema,
TeamPlansSchema,
bindSetupTeam,
setupTeamPlans,
createSetupCheckout,
createSetupSession,
loadSetupSession,
readSetupSessionForPages,
recordGithubEvent,
recordSetupError,
redeemSetupTicket,
reissueSetupTicket,
setupGithubInstall,
setupSessionView
} from './cloud-setup'
import { noTrialPort, type TrialPort } from './cloud-setup-trial'
const MAX_JSON_BYTES = 16 * 1024
@@ -61,7 +99,149 @@ async function readJson(request: Request): Promise<unknown> {
return text ? JSON.parse(text) : {}
}
export type Deps = { stripe?: StripeClient; now?: () => number; membership?: MembershipSource; orgMember?: OrgMemberCheck }
export type Deps = {
stripe?: StripeClient
now?: () => number
membership?: MembershipSource
orgMember?: OrgMemberCheck
trial?: TrialPort
fetch?: typeof fetch
}
const SETUP_SESSION_PATH = /^\/v1\/cloud-setup\/sessions\/(cs_[A-Za-z0-9_-]{22})(\/link)?$/
const INTERNAL_SETUP_PATH = /^\/v1\/internal\/cloud-setup\/sessions\/(cs_[A-Za-z0-9_-]{22})(?:\/(team|team-plans|checkout|github|error))?$/
async function handleCloudSetup(
request: Request,
env: Env,
url: URL,
now: number,
deps: { stripe: StripeClient; membership: MembershipSource; trial: TrialPort; fetch: typeof fetch }
): Promise<Response | null> {
const route = `${request.method} ${url.pathname}`
if (route === 'GET /v1/cloud-setup/offers') {
// Public: the setup pages show the trial and prices before anyone has signed in.
const offered = deps.trial.offeredSeconds(env)
return json({ ...publicOffers(planCatalog(env)), trial: offered ? { includedSeconds: offered } : null })
}
if (route === 'POST /v1/cloud-setup/sessions') {
const caller = await authenticateDesktop(env, request)
if (!caller) {
return json({ error: 'unauthorized' }, 401)
}
const body = CreateSetupSessionSchema.safeParse(await readJson(request))
if (!body.success) {
return json({ error: 'invalid_request' }, 400)
}
const created = await createSetupSession(env, caller, body.data, now)
return created.ok
? json({ id: created.id, url: created.url, expiresAt: created.expiresAt }, 201)
: json({ error: created.error }, created.status)
}
const desktopMatch = SETUP_SESSION_PATH.exec(url.pathname)
if (desktopMatch?.[2] && request.method === 'POST') {
const caller = await authenticateDesktop(env, request)
if (!caller) {
return json({ error: 'unauthorized' }, 401)
}
const link = await reissueSetupTicket(env, caller, desktopMatch[1]!, now)
return link ? json(link) : json({ error: 'not_found' }, 404)
}
if (desktopMatch && !desktopMatch[2] && request.method === 'GET') {
const caller = await authenticateDesktop(env, request)
if (!caller) {
return json({ error: 'unauthorized' }, 401)
}
const row = await loadSetupSession(env, desktopMatch[1]!, now)
if (!row || row.user_id !== caller.userId) {
return json({ error: 'not_found' }, 404)
}
return json(await setupSessionView(env, deps.trial, row, now))
}
if (route === 'POST /v1/internal/cloud-setup/github') {
if (!(await authenticateControlPlane(env, request))) {
return json({ error: 'unauthorized' }, 401)
}
const body = GithubEventSchema.safeParse(await readJson(request))
if (!body.success) {
return json({ error: 'invalid_request' }, 400)
}
return json({ ok: true, ...(await recordGithubEvent(env, body.data, now)) })
}
if (route === 'POST /v1/internal/cloud-setup/redeem') {
if (!(await authenticateMembershipSync(env, request))) {
return json({ error: 'unauthorized' }, 401)
}
const body = RedeemSchema.safeParse(await readJson(request))
if (!body.success) {
return json({ error: 'invalid_request' }, 400)
}
const redeemed = await redeemSetupTicket(env, body.data, now)
return redeemed ? json(redeemed) : json({ error: 'invalid_ticket' }, 404)
}
const internalMatch = INTERNAL_SETUP_PATH.exec(url.pathname)
if (!internalMatch) {
return null
}
if (!(await authenticateMembershipSync(env, request))) {
return json({ error: 'unauthorized' }, 401)
}
const id = internalMatch[1]!
const action = internalMatch[2]
if (!action && request.method === 'GET') {
const query = InternalReadSchema.safeParse({ userId: url.searchParams.get('userId') ?? '' })
if (!query.success) {
return json({ error: 'invalid_request' }, 400)
}
const session = await readSetupSessionForPages(env, deps.trial, id, query.data.userId, now)
return session ? json({ ...session, offers: publicOffers(planCatalog(env)) }) : json({ error: 'not_found' }, 404)
}
if (request.method !== 'POST' || !action) {
return json({ error: 'not_found' }, 404)
}
const raw = await readJson(request)
switch (action) {
case 'team': {
const body = BindTeamSchema.safeParse(raw)
if (!body.success) {
return json({ error: 'invalid_request' }, 400)
}
const bound = await bindSetupTeam(env, deps.trial, id, body.data, now)
return bound.ok ? json(bound) : json({ error: bound.error }, bound.status)
}
case 'team-plans': {
const body = TeamPlansSchema.safeParse(raw)
if (!body.success) {
return json({ error: 'invalid_request' }, 400)
}
const plans = await setupTeamPlans(env, deps.trial, id, body.data, now)
return plans ? json({ plans }) : json({ error: 'not_found' }, 404)
}
case 'checkout': {
const body = SetupCheckoutSchema.safeParse(raw)
if (!body.success) {
return json({ error: 'invalid_request' }, 400)
}
const outcome = await createSetupCheckout(env, deps.stripe, id, body.data, now, deps.membership)
return outcome.ok ? json({ url: outcome.url }) : json({ error: outcome.error }, outcome.status)
}
case 'github': {
const body = GithubInstallSchema.safeParse(raw)
if (!body.success) {
return json({ error: 'invalid_request' }, 400)
}
const outcome = await setupGithubInstall(env, id, body.data, now, deps.fetch)
return outcome.ok ? json({ access: outcome.access, url: outcome.url }) : json({ error: outcome.error }, outcome.status)
}
default: {
const body = SetupErrorSchema.safeParse(raw)
if (!body.success) {
return json({ error: 'invalid_request' }, 400)
}
return (await recordSetupError(env, id, body.data, now)) ? json({ ok: true }) : json({ error: 'not_found' }, 404)
}
}
}
export async function handleRequest(request: Request, env: Env, ctx: ExecutionContext, deps: Deps = {}): Promise<Response> {
const url = new URL(request.url)
@@ -70,6 +250,17 @@ export async function handleRequest(request: Request, env: Env, ctx: ExecutionCo
const membership = deps.membership ?? authMembershipSource(env)
const route = `${request.method} ${url.pathname}`
try {
if (url.pathname.startsWith('/v1/cloud-setup/') || url.pathname.startsWith('/v1/internal/cloud-setup/')) {
const handled = await handleCloudSetup(request, env, url, now, {
stripe,
membership,
trial: deps.trial ?? noTrialPort,
fetch: deps.fetch ?? fetch
})
if (handled) {
return handled
}
}
switch (route) {
case 'GET /return':
// Where Checkout and the Portal send the browser back; hands off to the desktop app.
@@ -111,7 +302,15 @@ export async function handleRequest(request: Request, env: Env, ctx: ExecutionCo
if (!body.success) {
return json({ error: 'invalid_request' }, 400)
}
const outcome = await createCheckout(env, stripe, caller, body.data, now, membership)
const { setupSessionId, ...checkout } = body.data
if (setupSessionId) {
// The plans dialog joins the open setup session only for its own user and team.
const session = await loadSetupSession(env, setupSessionId, now)
if (!session || session.user_id !== caller.userId || (session.account_id && session.account_id !== caller.accountId)) {
return json({ error: 'setup_session_mismatch' }, 409)
}
}
const outcome = await createCheckout(env, stripe, caller, checkout, now, membership, setupSessionId ? { setupSessionId } : {})
return outcome.ok ? json({ url: outcome.url }) : json({ error: outcome.error }, outcome.status)
}
@@ -12,7 +12,7 @@ describe('config: tax and plan catalog', () => {
['true', 'true']
] as const) {
const h = await createHarness(flag ? { STRIPE_AUTOMATIC_TAX: flag } : {})
const token = await h.desktopToken({ sub: 'u1' })
const token = await h.desktopToken({ sub: 'u1', org: 'o1', orgRole: 'owner' })
await h.call('POST', '/v1/billing/checkout', { body: { plan: 'team' }, headers: { authorization: `Bearer ${token}` } })
const session = h.stripe.calls.find((call) => call.method === 'POST' && call.path === '/v1/checkout/sessions')!
expect(session.form.get('automatic_tax[enabled]')).toBe(expected)
+6 -4
View File
@@ -67,7 +67,7 @@ describe('checkout and portal', () => {
expect(annual!.headers.get('idempotency-key')).toMatch(/^checkout:org:o1:/)
})
it('lets only org owners and admins buy or manage the plan; personal accounts manage themselves', async () => {
it('lets only org owners and admins buy or manage the plan; personal accounts must make a team first', async () => {
const h = await createHarness()
const member = await h.desktopToken({ sub: 'u2', org: 'o1', orgRole: 'member' })
const auth = { authorization: `Bearer ${member}` }
@@ -79,8 +79,10 @@ describe('checkout and portal', () => {
expect((await h.call('POST', '/v1/billing/overage', { body: { enabled: true }, headers: auth })).status).toBe(403)
const solo = await h.desktopToken({ sub: 'u3' })
expect((await h.call('POST', '/v1/billing/checkout', { body: { plan: 'team' }, headers: { authorization: `Bearer ${solo}` } })).status).toBe(200)
expect(h.stripe.customers.values().next().value?.metadata.account_id).toBe('user:u3')
expect((await h.call('POST', '/v1/billing/checkout', { body: { plan: 'team' }, headers: { authorization: `Bearer ${solo}` } })).body).toEqual({
error: 'team_required'
})
expect(h.stripe.customers.size).toBe(0)
})
it('rejects bad tokens, unknown plans and a second subscription', async () => {
@@ -470,7 +472,7 @@ describe('entitlements, overage and usage', () => {
it('refuses to run with a live Stripe key', async () => {
const h = await createHarness({ STRIPE_SECRET_KEY: 'sk_live_nope' })
const token = await h.desktopToken({ sub: 'u1' })
const token = await h.desktopToken({ sub: 'u1', org: 'o1', orgRole: 'owner' })
expect(await h.call('POST', '/v1/billing/checkout', { body: { plan: 'team' }, headers: { authorization: `Bearer ${token}` } })).toEqual({
status: 503,
body: { error: 'billing_misconfigured' }
+251
View File
@@ -0,0 +1,251 @@
import { describe, expect, it } from 'vitest'
import type { TrialPort, SetupTrial } from '../src/cloud-setup-trial'
import { normalizeRepo } from '../src/cloud-setup'
import { checkoutCompleted } from './stripe-fake'
import { CONTROL_TOKEN, createHarness } from './harness'
const SYNC = 'sync_test_0123456789abcdef0123456789abcdef'
const REPO = 'https://github.com/Acme/Web.git'
/** In-memory trial backend: one 2-hour trial per account, exhausted on demand. */
function fakeTrials(options: { refuse?: boolean } = {}) {
const trials = new Map<string, SetupTrial>()
const grants: string[] = []
const port: TrialPort = {
offeredSeconds: () => 7200,
current: async (_env, accountId) => trials.get(accountId) ?? null,
grant: async (_env, input) => {
grants.push(input.accountId)
if (options.refuse) {
return { ok: false, reason: 'trial_unavailable' }
}
const trial = trials.get(input.accountId) ?? { includedSeconds: 7200, usedSeconds: 0, exhausted: false }
trials.set(input.accountId, trial)
return { ok: true, trial }
}
}
return { port, trials, grants }
}
async function setup(options: { refuseTrial?: boolean } = {}) {
const h = await createHarness({ MEMBERSHIP_SYNC_TOKEN: SYNC, CLOUD_SETUP_PAGES_URL: 'https://auth.test', SANDBOX_CONTROL_URL: 'https://cp.test' })
const trials = fakeTrials({ refuse: options.refuseTrial })
h.setTrial(trials.port)
const sync = { authorization: `Bearer ${SYNC}` }
const personal = { authorization: `Bearer ${await h.desktopToken({ sub: 'u1', email: 'neil@acme.dev' })}` }
const create = async (body: Record<string, unknown> = { repo: REPO, needs: ['plan', 'github'], device: 'MacBook Pro' }, auth = personal) =>
h.call('POST', '/v1/cloud-setup/sessions', { body, headers: auth })
const poll = (id: string, auth = personal) => h.call('GET', `/v1/cloud-setup/sessions/${id}`, { headers: auth })
const pages = {
redeem: (sessionId: string, ticket: string) => h.call('POST', '/v1/internal/cloud-setup/redeem', { body: { sessionId, ticket }, headers: sync }),
read: (id: string, userId = 'u1') => h.call('GET', `/v1/internal/cloud-setup/sessions/${id}?userId=${userId}`, { headers: sync }),
post: (id: string, action: string, body: unknown) => h.call('POST', `/v1/internal/cloud-setup/sessions/${id}/${action}`, { body, headers: sync })
}
return { h, trials, create, poll, pages, personal }
}
function ticketOf(url: string): { session: string; ticket: string } {
const parsed = new URL(url)
return { session: parsed.searchParams.get('session')!, ticket: parsed.searchParams.get('ticket')! }
}
describe('cloud setup sessions', () => {
it('publishes the trial and prices for the pages without auth', async () => {
const { h } = await setup()
const offers = await h.call('GET', '/v1/cloud-setup/offers')
expect(offers.body.trial).toEqual({ includedSeconds: 7200 })
expect(offers.body.team.monthlyPriceLabel).toMatch(/per seat per month/)
})
it('normalizes GitHub repositories', () => {
expect(normalizeRepo('https://github.com/Acme/Web.git/')).toBe('https://github.com/acme/web')
expect(normalizeRepo('git@github.com:acme/web.git')).toBe('https://github.com/acme/web')
expect(normalizeRepo('https://gitlab.com/acme/web')).toBeNull()
})
it('chains a new user through team (trial granted), then GitHub, then finishes', async () => {
const { h, trials, create, poll, pages, personal } = await setup()
const created = await create()
expect(created.status).toBe(201)
expect(created.body.id).toMatch(/^cs_[A-Za-z0-9_-]{22}$/)
const { session, ticket } = ticketOf(created.body.url)
expect(created.body.url).toMatch(/^https:\/\/auth\.test\/cloud\/setup\/start\?/)
expect(session).toBe(created.body.id)
// Personal account: the team step is added (O1) and is the active one.
expect((await poll(session)).body.steps).toEqual([
{ id: 'account', state: 'done' },
{ id: 'team', state: 'active' },
{ id: 'plan', state: 'pending' },
{ id: 'github', state: 'pending' }
])
// The ticket redeems exactly once, and only with the right value.
expect((await pages.redeem(session, 'x'.repeat(43))).status).toBe(404)
expect((await pages.redeem(session, ticket)).body).toEqual({ userId: 'u1' })
expect((await pages.redeem(session, ticket)).status).toBe(404)
// "Copy setup link" mints a fresh one-time link for another browser.
const link = await h.call('POST', `/v1/cloud-setup/sessions/${session}/link`, { headers: personal })
expect((await pages.redeem(session, ticketOf(link.body.url).ticket)).body).toEqual({ userId: 'u1' })
// Pages read it as the session's user only.
expect((await pages.read(session, 'u2')).status).toBe(404)
const read = await pages.read(session)
expect(read.body).toMatchObject({ ownerHint: 'acme', device: 'MacBook Pro', needs: ['plan', 'github', 'team'] })
const bound = await pages.post(session, 'team', { userId: 'u1', orgId: 'o_acme', name: 'acme', created: true, githubOwnerId: 42 })
expect(bound.body).toEqual({ ok: true, trial: 'granted' })
expect(trials.grants).toEqual(['org:o_acme'])
const afterTeam = (await poll(session)).body
expect(afterTeam.team).toEqual({ orgId: 'o_acme', name: 'acme', created: true })
expect(afterTeam.plan).toBe('trial')
expect(afterTeam.trial).toEqual({ includedSeconds: 7200, usedSeconds: 0, exhausted: false })
expect(afterTeam.steps.map((s: { state: string }) => s.state)).toEqual(['done', 'done', 'done', 'active'])
// GitHub: the control plane hands out the install URL, then reports the bind.
const seen: string[] = []
h.setFetch(async (input) => {
seen.push(String(input))
return Response.json({ access: 'missing', url: 'https://github.com/apps/orca-cloud/installations/new?state=s' })
})
const install = await pages.post(session, 'github', { userId: 'u1', githubUserId: 7, githubLogin: 'neil-acme' })
expect(install.body).toEqual({ access: 'missing', url: 'https://github.com/apps/orca-cloud/installations/new?state=s' })
const asked = new URL(seen[0]!)
expect(asked.origin + asked.pathname).toBe('https://cp.test/v1/internal/github/install-url')
expect(Object.fromEntries(asked.searchParams)).toEqual({
accountId: 'org:o_acme',
userId: 'u1',
repo: 'https://github.com/acme/web',
session,
githubUserId: '7',
githubLogin: 'neil-acme'
})
const event = await h.controlPlane('/v1/internal/cloud-setup/github', {
sessionId: session,
accountId: 'org:o_acme',
repo: 'https://github.com/Acme/web',
state: 'done'
})
expect(event.body).toEqual({ ok: true, matched: 1 })
const finished = (await poll(session)).body
expect(finished.finished).toBe(true)
expect(finished.error).toBeNull()
})
it('sends a team whose trial is used up through T3 Checkout that returns to the setup pages', async () => {
const { h, trials, create, poll, pages } = await setup()
trials.trials.set('org:o1', { includedSeconds: 7200, usedSeconds: 7200, exhausted: true })
const owner = { authorization: `Bearer ${await h.desktopToken({ sub: 'u1', org: 'o1', orgRole: 'owner' })}` }
const created = await create({ needs: ['plan'] }, owner)
const id = created.body.id
// The active team is kept: team done, plan active.
expect((await poll(id, owner)).body.steps).toEqual([
{ id: 'account', state: 'done' },
{ id: 'team', state: 'done' },
{ id: 'plan', state: 'active' }
])
expect((await pages.post(id, 'checkout', { userId: 'u1', orgRole: 'member', interval: 'year' })).status).toBe(403)
const checkout = await pages.post(id, 'checkout', { userId: 'u1', orgRole: 'owner', interval: 'year', email: 'a@acme.dev' })
expect(checkout.status).toBe(200)
const call = h.stripe.calls.find((c) => c.method === 'POST' && c.path === '/v1/checkout/sessions')!
expect(call.form.get('line_items[0][price]')).toBe('price_team_year')
expect(call.form.get('success_url')).toBe(`https://auth.test/cloud/setup/next?session=${id}&from=checkout&checkout=success`)
expect(call.form.get('cancel_url')).toBe(`https://auth.test/cloud/setup/plan?session=${id}&checkout=canceled`)
expect(call.form.get('metadata[setup_session_id]')).toBe(id)
expect((await poll(id, owner)).body.steps[2]).toEqual({ id: 'plan', state: 'active', detail: 'checkout' })
// Canceled: the tracker gets checkout_canceled and the plan row fails.
await pages.post(id, 'error', { userId: 'u1', kind: 'checkout_canceled' })
const canceled = (await poll(id, owner)).body
expect(canceled.error).toEqual({ kind: 'checkout_canceled' })
expect(canceled.steps[2].state).toBe('failed')
// Paid: the subscription ends the plan step.
const customer = [...h.stripe.customers.keys()][0]!
const subscription = h.stripe.putSubscription({
customer,
accountId: 'org:o1',
basePrice: 'price_team_year',
quantity: 1,
periodStart: Math.floor(Date.now() / 1000),
periodEnd: Math.floor(Date.now() / 1000) + 365 * 86400
})
await h.webhook(checkoutCompleted({ customer, subscription: subscription.id, accountId: 'org:o1' }))
const paid = (await poll(id, owner)).body
expect(paid.plan).toBe('subscription')
expect(paid.finished).toBe(true)
})
it('keeps the plan step when the trial is refused, and never lets another user or team in', async () => {
const { h, create, poll, pages } = await setup({ refuseTrial: true })
const id = (await create({ needs: ['plan'] })).body.id
expect((await pages.post(id, 'team', { userId: 'u2', orgId: 'o9', name: 'x' })).status).toBe(404)
expect((await pages.post(id, 'team', { userId: 'u1', orgId: 'o1', name: 'acme' })).body).toEqual({ ok: true, trial: 'unavailable' })
expect((await pages.post(id, 'team', { userId: 'u1', orgId: 'o2', name: 'other' })).status).toBe(409)
// A rename of the same team is fine.
expect((await pages.post(id, 'team', { userId: 'u1', orgId: 'o1', name: 'acme-web' })).status).toBe(200)
expect((await poll(id)).body.team).toEqual({ orgId: 'o1', name: 'acme-web', created: false })
const stranger = { authorization: `Bearer ${await h.desktopToken({ sub: 'u2' })}` }
expect((await poll(id, stranger)).status).toBe(404)
expect((await h.call('GET', `/v1/cloud-setup/sessions/${id}`)).status).toBe(401)
expect((await h.call('GET', `/v1/internal/cloud-setup/sessions/${id}?userId=u1`, { headers: { authorization: `Bearer ${CONTROL_TOKEN}` } })).status).toBe(401)
})
it('reports a stalled session as timed out and expires it after two hours', async () => {
const { h, create, poll } = await setup()
const start = Date.now()
h.setNow(start)
const id = (await create({ needs: ['plan'] })).body.id
h.setNow(start + 16 * 60_000)
expect((await poll(id)).body.error).toEqual({ kind: 'timed_out' })
h.setNow(start + 2 * 3600_000 + 1)
expect((await poll(id)).status).toBe(404)
})
it('rate limits session creation per user', async () => {
const { create } = await setup()
for (let i = 0; i < 20; i++) {
expect((await create({ needs: ['plan'] })).status).toBe(201)
}
expect((await create({ needs: ['plan'] })).status).toBe(429)
})
it('matches control-plane GitHub events without a session id on account and repo', async () => {
const { h, create, poll, pages } = await setup()
const id = (await create()).body.id
await pages.post(id, 'team', { userId: 'u1', orgId: 'o1', name: 'acme' })
expect((await h.controlPlane('/v1/internal/cloud-setup/github', { accountId: 'org:o1', repo: 'https://github.com/acme/web', state: 'pending' })).body).toEqual({ ok: true, matched: 1 })
expect((await poll(id)).body.steps.at(-1)).toEqual({ id: 'github', state: 'active', detail: 'requested' })
expect((await h.controlPlane('/v1/internal/cloud-setup/github', { accountId: 'org:o1', repo: 'https://github.com/acme/web', state: 'done' })).body.matched).toBe(1)
// A late 'pending' never undoes 'done'.
expect((await h.controlPlane('/v1/internal/cloud-setup/github', { accountId: 'org:o1', repo: 'https://github.com/acme/web', state: 'pending' })).body.matched).toBe(0)
expect((await h.controlPlane('/v1/internal/cloud-setup/github', { accountId: 'org:o1', repo: 'x', state: 'done' }, 'wrong-token-0123456789abcdef0123456789')).status).toBe(401)
})
})
describe('team-first checkout (O1/N4)', () => {
it('refuses a personal-account Checkout with team_required', async () => {
const h = await createHarness()
const solo = await h.desktopToken({ sub: 'u3' })
expect(await h.call('POST', '/v1/billing/checkout', { body: { plan: 'team' }, headers: { authorization: `Bearer ${solo}` } })).toEqual({
status: 409,
body: { error: 'team_required' }
})
expect(h.stripe.customers.size).toBe(0)
})
it('lets the plans dialog join its own setup session only', async () => {
const h = await createHarness({ MEMBERSHIP_SYNC_TOKEN: SYNC, CLOUD_SETUP_PAGES_URL: 'https://auth.test' })
const owner = { authorization: `Bearer ${await h.desktopToken({ sub: 'u1', org: 'o1', orgRole: 'owner' })}` }
const other = { authorization: `Bearer ${await h.desktopToken({ sub: 'u2', org: 'o1', orgRole: 'owner' })}` }
const id = (await h.call('POST', '/v1/cloud-setup/sessions', { body: { needs: ['plan'] }, headers: owner })).body.id
expect((await h.call('POST', '/v1/billing/checkout', { body: { plan: 'team', setupSessionId: id }, headers: other })).body).toEqual({
error: 'setup_session_mismatch'
})
const joined = await h.call('POST', '/v1/billing/checkout', { body: { plan: 'team', setupSessionId: id }, headers: owner })
expect(joined.status).toBe(200)
const call = h.stripe.calls.find((c) => c.method === 'POST' && c.path === '/v1/checkout/sessions')!
expect(call.form.get('success_url')).toContain(`/cloud/setup/next?session=${id}`)
})
})
+12 -1
View File
@@ -5,6 +5,7 @@ import { createStripeClient } from '../src/stripe'
import type { OrgMemberCheck } from '../src/team-plans'
import { createFakeD1 } from './d1-fake'
import { createFakeStripe, signStripePayload } from './stripe-fake'
import type { TrialPort } from '../src/cloud-setup-trial'
export const WEBHOOK_SECRET = 'whsec_test_local_fixture_secret'
export const CONTROL_TOKEN = 'cp_test_0123456789abcdef0123456789abcdef'
@@ -35,6 +36,8 @@ export async function createHarness(overrides: Partial<Env> = {}) {
let membership: (orgId: string) => Promise<number | null> = async () => null
// Auth's live org-member check (cloud start B2); null = auth unavailable (the default).
let orgMember: OrgMemberCheck = async () => null
let trial: TrialPort | undefined
let outboundFetch: typeof fetch | undefined
const waits: Promise<unknown>[] = []
const ctx = { waitUntil: (promise: Promise<unknown>) => waits.push(promise), passThroughOnException() {} } as unknown as ExecutionContext
@@ -48,7 +51,9 @@ export async function createHarness(overrides: Partial<Env> = {}) {
stripe: createStripeClient(env, stripe.fetchImpl),
now: () => now,
membership: (orgId) => membership(orgId),
orgMember: (orgId, billingToken) => orgMember(orgId, billingToken)
orgMember: (orgId, billingToken) => orgMember(orgId, billingToken),
...(trial ? { trial } : {}),
...(outboundFetch ? { fetch: outboundFetch } : {})
})
await Promise.all(waits.splice(0))
return { status: response.status, body: (await response.json()) as Record<string, any> }
@@ -68,6 +73,12 @@ export async function createHarness(overrides: Partial<Env> = {}) {
setOrgMember(check: OrgMemberCheck) {
orgMember = check
},
setTrial(port: TrialPort) {
trial = port
},
setFetch(impl: typeof fetch) {
outboundFetch = impl
},
async desktopToken(claims: { sub: string; org?: string; orgRole?: string; email?: string; orgMembers?: number }, options: { audience?: string; purpose?: string; ageSeconds?: number } = {}) {
const iat = Math.floor(now / 1000) - (options.ageSeconds ?? 0)
return new SignJWT({ ...claims, purpose: options.purpose ?? 'billing' })
+4 -1
View File
@@ -38,6 +38,9 @@
// (secret MEMBERSHIP_SYNC_TOKEN must equal staging's ORCA_CLOUD_BILLING_MEMBERSHIP_TOKEN).
"BILLING_STAGING_JWKS_URL": "https://auth-staging.onorca.dev/.well-known/jwks.json",
"BILLING_STAGING_AUTH_ISSUER": "https://auth-staging.onorca.dev",
"AUTH_INTERNAL_URL": "https://auth-staging.onorca.dev"
"AUTH_INTERNAL_URL": "https://auth-staging.onorca.dev",
// Cloud setup sessions: pages on staging auth, GitHub install URLs from the dev control plane.
"CLOUD_SETUP_PAGES_URL": "https://auth-staging.onorca.dev",
"SANDBOX_CONTROL_URL": "https://orca-sandbox-control-dev.lovecast.workers.dev"
}
}
+7 -2
View File
@@ -68,7 +68,7 @@ export async function mintBillingToken(
return body.data.billingToken
}
async function billingRequest(
export async function billingRequest(
endpoints: BillingEndpoints,
token: string,
method: 'GET' | 'POST',
@@ -221,7 +221,12 @@ export async function createCheckoutUrl(
token,
'POST',
'v1/billing/checkout',
{ plan: args.plan, interval: args.interval, seats: args.seats },
{
plan: args.plan,
interval: args.interval,
seats: args.seats,
...(args.setupSessionId ? { setupSessionId: args.setupSessionId } : {})
},
fetchImpl
)
return assertStripeHostedUrl(UrlBody.safeParse(body).data?.url)
+35 -2
View File
@@ -106,6 +106,22 @@ function prepare(userDataPath: string): Ready {
}
}
/**
* Runs one billing-service call with a fresh billing token for the active profile (cloud setup
* uses it for its session calls). 'signed-out' when there is no usable Orca session.
*/
export async function withBillingToken<T>(
userDataPath: string,
call: (token: string, endpoints: BillingEndpoints) => Promise<T>
): Promise<{ status: 'ok'; value: T } | { status: 'unconfigured' | 'signed-out' }> {
const ready = prepare(userDataPath)
if (!ready.ok) {
return { status: ready.status }
}
const value = await ready.run(call)
return value === 'signed-out' ? { status: 'signed-out' } : { status: 'ok', value }
}
const message = (error: unknown): string => (error instanceof Error ? error.message : String(error))
export async function getOrcaBillingStatus(userDataPath: string): Promise<OrcaBillingStatusResult> {
@@ -152,6 +168,9 @@ function openResultForError(error: unknown): OrcaBillingOpenResult {
if (error.errorCode === 'no_billing_account') {
return { status: 'no-billing-account' }
}
if (error.errorCode === 'team_required') {
return { status: 'team-required' }
}
}
return { status: 'failed', error: message(error) }
}
@@ -183,11 +202,25 @@ async function openHosted(
}
}
export function openOrcaBillingCheckout(
export async function openOrcaBillingCheckout(
userDataPath: string,
args: OrcaBillingCheckoutArgs
): Promise<OrcaBillingOpenResult> {
return openHosted(userDataPath, (token, endpoints) => createCheckoutUrl(endpoints, token, args))
const result = await openHosted(userDataPath, (token, endpoints) =>
createCheckoutUrl(endpoints, token, args)
)
// A setup session for another team or user (or an expired one) must not block buying.
if (
args.setupSessionId &&
result.status === 'failed' &&
/setup_session_mismatch/.test(result.error)
) {
const { setupSessionId: _dropped, ...plain } = args
return openHosted(userDataPath, (token, endpoints) =>
createCheckoutUrl(endpoints, token, plain)
)
}
return result
}
export function openOrcaBillingPortal(userDataPath: string): Promise<OrcaBillingOpenResult> {
@@ -0,0 +1,104 @@
import { describe, expect, it, vi } from 'vitest'
vi.mock('electron', () => ({ app: { isPackaged: false }, shell: { openExternal: vi.fn() } }))
import {
createSetupSessionRequest,
getSetupSessionRequest,
setupDeviceLabel
} from './cloud-setup-service'
import { cloudSetupStartArgsFromUnknown } from '../ipc/profiles/orca-profile-billing-handlers'
const endpoints = {
billingApiUrl: 'https://billing.test',
billingTokenEndpoint: 'https://auth.test/t'
}
const ID = 'cs_AAAAAAAAAAAAAAAAAAAAAA'
function fakeFetch(body: unknown, status = 200) {
const calls: { url: string; init: RequestInit }[] = []
const impl: typeof fetch = async (url, init) => {
calls.push({ url: String(url), init: init ?? {} })
return new Response(JSON.stringify(body), { status })
}
return { impl, calls }
}
describe('cloud setup service', () => {
it('creates a session with the billing token and returns its one-tab URL', async () => {
const { impl, calls } = fakeFetch({
id: ID,
url: `https://auth-staging.onorca.dev/cloud/setup/start?session=${ID}&ticket=t`,
expiresAt: 1
})
const created = await createSetupSessionRequest(
endpoints,
'tok',
{
repo: 'https://github.com/acme/web',
needs: ['plan', 'github'],
device: 'MacBook Pro',
useActiveTeam: true
},
impl
)
expect(created.id).toBe(ID)
expect(calls[0]!.url).toBe('https://billing.test/v1/cloud-setup/sessions')
expect(JSON.parse(String(calls[0]!.init.body))).toEqual({
repo: 'https://github.com/acme/web',
needs: ['plan', 'github'],
device: 'MacBook Pro',
useActiveTeam: true
})
expect(new Headers(calls[0]!.init.headers).get('authorization')).toBe('Bearer tok')
})
it('refuses a session URL that is not https', async () => {
const { impl } = fakeFetch({ id: ID, url: 'http://evil.test/x', expiresAt: 1 })
await expect(
createSetupSessionRequest(
endpoints,
'tok',
{ needs: ['plan'], device: 'x', useActiveTeam: true },
impl
)
).rejects.toThrow('invalid_setup_session')
})
it('reads steps, team, trial and errors, dropping unknown error kinds', async () => {
const { impl } = fakeFetch({
id: ID,
steps: [
{ id: 'account', state: 'done' },
{ id: 'team', state: 'done', detail: 'acme' },
{ id: 'plan', state: 'failed' }
],
team: { orgId: 'org_1', name: 'acme', created: true },
trial: null,
plan: null,
finished: false,
error: { kind: 'something_new' },
expiresAt: 5
})
const session = await getSetupSessionRequest(endpoints, 'tok', ID, impl)
expect(session.steps).toHaveLength(3)
expect(session.team).toEqual({ orgId: 'org_1', name: 'acme', created: true })
expect(session.error).toBeNull()
})
it('labels the device from the host name', () => {
expect(setupDeviceLabel('Neils-MacBook-Pro.local')).toBe('Neils MacBook Pro')
expect(setupDeviceLabel('')).toBe('this computer')
})
it('validates start args from the renderer', () => {
expect(cloudSetupStartArgsFromUnknown({ needs: ['team', 'plan'], chooseTeam: true })).toEqual({
needs: ['team', 'plan'],
chooseTeam: true
})
expect(() =>
cloudSetupStartArgsFromUnknown({ needs: ['team'], repo: 'https://gitlab.com/a/b' })
).toThrow()
expect(() => cloudSetupStartArgsFromUnknown({ needs: ['bogus'] })).toThrow()
})
})
+240
View File
@@ -0,0 +1,240 @@
// Orca Cloud setup session (NP-4 N1), desktop side. "Set up and start" opens ONE browser tab:
// - signed out: the sign-in tab shows the setup account page (A2); once the code is exchanged,
// the session is created and the same tab continues to the setup pages;
// - signed in: the session is created and its start URL is opened.
// The composer then polls getCloudSetupSession until every step is done.
import { appendFile } from 'node:fs/promises'
import { hostname } from 'node:os'
import { app, shell } from 'electron'
import { z } from 'zod'
import {
CLOUD_SETUP_ERROR_KINDS,
CLOUD_SETUP_SESSION_ID,
type CloudSetupGetResult,
type CloudSetupLinkResult,
type CloudSetupNeed,
type CloudSetupSession,
type CloudSetupStartArgs,
type CloudSetupStartResult
} from '../../shared/orca-cloud-setup'
import { connectCurrentOrcaProfile } from '../orca-profiles/profile-cloud-service'
import { billingRequest, BillingServiceError, type BillingEndpoints } from './billing-client'
import { withBillingToken } from './billing-service'
const CreatedBody = z.object({
id: z.string().regex(CLOUD_SETUP_SESSION_ID),
url: z.string().url().startsWith('https://'),
expiresAt: z.number()
})
const StepBody = z.object({
id: z.enum(['account', 'team', 'plan', 'github']),
state: z.enum(['done', 'needed', 'active', 'pending', 'failed', 'optional']),
detail: z.string().max(200).optional()
})
const SessionBody = z.object({
id: z.string().regex(CLOUD_SETUP_SESSION_ID),
steps: z.array(StepBody).max(8),
team: z
.object({
orgId: z.string().max(128),
name: z.string().max(200).nullable(),
created: z.boolean()
})
.nullable()
.catch(null),
trial: z
.object({ includedSeconds: z.number(), usedSeconds: z.number(), exhausted: z.boolean() })
.nullable()
.catch(null),
plan: z.enum(['subscription', 'trial']).nullable().catch(null),
finished: z.boolean(),
error: z
.object({ kind: z.enum(CLOUD_SETUP_ERROR_KINDS), detail: z.string().max(320).optional() })
.nullable()
.catch(null),
expiresAt: z.number()
})
/** What this Mac is called on the setup page ("Orca on MacBook Pro is waiting for you"). */
export function setupDeviceLabel(name = hostname()): string {
return (
name
.replace(/\.local$/i, '')
.replace(/[-_]+/g, ' ')
.trim()
.slice(0, 80) || 'this computer'
)
}
export async function createSetupSessionRequest(
endpoints: BillingEndpoints,
token: string,
body: { repo?: string; needs: CloudSetupNeed[]; device: string; useActiveTeam: boolean },
fetchImpl: typeof fetch = fetch
): Promise<z.infer<typeof CreatedBody>> {
const created = CreatedBody.safeParse(
await billingRequest(endpoints, token, 'POST', 'v1/cloud-setup/sessions', body, fetchImpl)
)
if (!created.success) {
throw new Error('invalid_setup_session')
}
return created.data
}
export async function getSetupSessionRequest(
endpoints: BillingEndpoints,
token: string,
sessionId: string,
fetchImpl: typeof fetch = fetch
): Promise<CloudSetupSession> {
const session = SessionBody.safeParse(
await billingRequest(
endpoints,
token,
'GET',
`v1/cloud-setup/sessions/${sessionId}`,
undefined,
fetchImpl
)
)
if (!session.success) {
throw new Error('invalid_setup_session')
}
return session.data
}
async function openInBrowser(url: string): Promise<void> {
// Dev automation only: hand the URL to a test driver instead of the user's browser.
const devUrlFile = app.isPackaged
? ''
: (process.env.ORCA_BILLING_DEV_OPEN_URL_FILE?.trim() ?? '')
await (devUrlFile ? appendFile(devUrlFile, `${url}\n`, { mode: 0o600 }) : shell.openExternal(url))
}
const message = (error: unknown): string => (error instanceof Error ? error.message : String(error))
export async function startCloudSetup(
userDataPath: string,
args: CloudSetupStartArgs
): Promise<CloudSetupStartResult> {
const device = setupDeviceLabel()
const body = {
...(args.repo ? { repo: args.repo } : {}),
needs: args.needs,
device,
useActiveTeam: !args.chooseTeam
}
const create = (): ReturnType<typeof withBillingToken<z.infer<typeof CreatedBody>>> =>
withBillingToken(userDataPath, (token, endpoints) =>
createSetupSessionRequest(endpoints, token, body)
)
try {
const signedIn = await create()
if (signedIn.status === 'ok') {
await openInBrowser(signedIn.value.url)
return { status: 'opened', sessionId: signedIn.value.id, expiresAt: signedIn.value.expiresAt }
}
if (signedIn.status === 'unconfigured') {
return { status: 'unconfigured' }
}
// Signed out: one tab signs in and then carries on into setup.
// Filled in by afterSignIn, inside the sign-in flow.
const outcome: { created: z.infer<typeof CreatedBody> | null; error: unknown } = {
created: null,
error: null
}
const connected = await connectCurrentOrcaProfile(userDataPath, {
authorizeParams: {
setup: '1',
device,
// New users skip the team page (made for them), so only plan/GitHub are announced.
setup_steps: args.needs.filter((need) => need !== 'team').join(',')
},
afterSignIn: async () => {
try {
const result = await create()
outcome.created = result.status === 'ok' ? result.value : null
} catch (error) {
outcome.error = error
}
return outcome.created?.url ?? null
}
})
if (connected.status === 'cancelled' || connected.status === 'timed-out') {
return { status: 'cancelled' }
}
if (connected.status !== 'connected') {
return connected.status === 'unconfigured'
? { status: 'unconfigured' }
: { status: 'failed', error: connected.error }
}
const session = outcome.created
if (!session) {
return {
status: 'failed',
error: outcome.error ? message(outcome.error) : 'setup_session_unavailable'
}
}
return { status: 'opened', sessionId: session.id, expiresAt: session.expiresAt }
} catch (error) {
return { status: 'failed', error: message(error) }
}
}
export async function getCloudSetupSession(
userDataPath: string,
sessionId: string
): Promise<CloudSetupGetResult> {
if (!CLOUD_SETUP_SESSION_ID.test(sessionId)) {
return { status: 'not-found' }
}
try {
const result = await withBillingToken(userDataPath, (token, endpoints) =>
getSetupSessionRequest(endpoints, token, sessionId)
)
return result.status === 'ok' ? { status: 'ok', session: result.value } : result
} catch (error) {
if (error instanceof BillingServiceError && error.statusCode === 404) {
return { status: 'not-found' }
}
return { status: 'failed', error: message(error) }
}
}
const LinkBody = z.object({ url: z.string().url().startsWith('https://') })
/** "Copy setup link": a fresh one-time link to the same session, for a different browser. */
export async function getCloudSetupLink(
userDataPath: string,
sessionId: string
): Promise<CloudSetupLinkResult> {
if (!CLOUD_SETUP_SESSION_ID.test(sessionId)) {
return { status: 'not-found' }
}
try {
const result = await withBillingToken(userDataPath, async (token, endpoints) => {
const body = LinkBody.safeParse(
await billingRequest(
endpoints,
token,
'POST',
`v1/cloud-setup/sessions/${sessionId}/link`,
{},
fetch
)
)
if (!body.success) {
throw new Error('invalid_setup_link')
}
return body.data.url
})
return result.status === 'ok' ? { status: 'ok', url: result.value } : result
} catch (error) {
if (error instanceof BillingServiceError && error.statusCode === 404) {
return { status: 'not-found' }
}
return { status: 'failed', error: message(error) }
}
}
@@ -26,12 +26,26 @@ import { ensureActiveOrcaProfile } from '../../orca-profiles/profile-index-store
import { notifyUsageAlertIfDue } from '../../billing/usage-alert-notifier'
import { showUsageAlertNotification, usageAlertBody } from '../../billing/usage-alert-desktop'
import type { Store } from '../../persistence/loading-store/store'
import {
CLOUD_SETUP_NEEDS,
CLOUD_SETUP_SESSION_ID,
type CloudSetupGetResult,
type CloudSetupLinkResult,
type CloudSetupStartArgs,
type CloudSetupStartResult
} from '../../../shared/orca-cloud-setup'
import {
getCloudSetupLink,
getCloudSetupSession,
startCloudSetup
} from '../../billing/cloud-setup-service'
const CheckoutArgs = z
.object({
plan: z.enum(ORCA_BILLING_PLAN_IDS),
interval: z.enum(ORCA_BILLING_INTERVALS),
seats: z.number().int().min(1).max(ORCA_BILLING_MAX_SEATS)
seats: z.number().int().min(1).max(ORCA_BILLING_MAX_SEATS),
setupSessionId: z.string().regex(CLOUD_SETUP_SESSION_ID).optional()
})
.strict()
@@ -65,6 +79,24 @@ export function billingTeamPlansArgsFromUnknown(args: unknown): { orgIds: string
return { orgIds: [...new Set(parsed.data.orgIds)] }
}
const CloudSetupStart = z
.object({
repo: z.string().url().startsWith('https://github.com/').max(300).optional(),
needs: z.array(z.enum(CLOUD_SETUP_NEEDS)).max(3),
chooseTeam: z.boolean().optional()
})
.strict()
const CloudSetupGet = z.object({ sessionId: z.string().regex(CLOUD_SETUP_SESSION_ID) }).strict()
export function cloudSetupStartArgsFromUnknown(args: unknown): CloudSetupStartArgs {
const parsed = CloudSetupStart.safeParse(args)
if (!parsed.success) {
throw new Error('invalid_cloud_setup_start')
}
return parsed.data
}
export function billingCheckoutArgsFromUnknown(args: unknown): OrcaBillingCheckoutArgs {
const parsed = CheckoutArgs.safeParse(args)
if (!parsed.success) {
@@ -122,6 +154,29 @@ export function registerOrcaProfileBillingHandlers(store: Store): void {
billingTeamPlansArgsFromUnknown(rawArgs).orgIds
)
)
ipcMain.handle(
'orcaProfiles:cloudSetupStart',
async (_event, rawArgs: unknown): Promise<CloudSetupStartResult> =>
startCloudSetup(getProfileUserDataPath(), cloudSetupStartArgsFromUnknown(rawArgs))
)
ipcMain.handle(
'orcaProfiles:cloudSetupGet',
async (_event, rawArgs: unknown): Promise<CloudSetupGetResult> => {
const parsed = CloudSetupGet.safeParse(rawArgs)
return parsed.success
? getCloudSetupSession(getProfileUserDataPath(), parsed.data.sessionId)
: { status: 'not-found' }
}
)
ipcMain.handle(
'orcaProfiles:cloudSetupLink',
async (_event, rawArgs: unknown): Promise<CloudSetupLinkResult> => {
const parsed = CloudSetupGet.safeParse(rawArgs)
return parsed.success
? getCloudSetupLink(getProfileUserDataPath(), parsed.data.sessionId)
: { status: 'not-found' }
}
)
ipcMain.handle('orcaProfiles:billingOpenPortal', async (): Promise<OrcaBillingOpenResult> =>
openOrcaBillingPortal(getProfileUserDataPath())
)
@@ -0,0 +1,78 @@
import { mkdtempSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, describe, expect, it, vi } from 'vitest'
vi.mock('electron', () => ({ app: { isPackaged: false }, shell: { openExternal: vi.fn() } }))
import type { OrcaCloudAuthConfig } from './profile-cloud-auth-config'
import { beginOrcaCloudPkceFlow } from './profile-cloud-pkce'
const base = 'https://auth.test'
const config: OrcaCloudAuthConfig = {
apiBaseUrl: base,
authorizeEndpoint: `${base}/v1/desktop/auth/authorize`,
sessionEndpoint: `${base}/s`,
refreshEndpoint: `${base}/r`,
capabilitiesEndpoint: `${base}/c`,
profileEndpoint: `${base}/p`,
orgEndpoint: `${base}/o`,
logoutEndpoint: `${base}/l`,
relayTokenEndpoint: `${base}/rt`,
connectorTokenEndpoint: `${base}/ct`,
relayDirectorUrl: base,
clientId: 'orca-desktop',
scope: 'openid'
}
afterEach(() => {
delete process.env.ORCA_CLOUD_DEV_OPEN_URL_FILE
})
describe('PKCE loopback for cloud setup', () => {
it('adds the setup parameters and holds the tab until setup says where it goes next', async () => {
process.env.ORCA_CLOUD_DEV_OPEN_URL_FILE = join(mkdtempSync(join(tmpdir(), 'pkce-')), 'urls')
let authorize = ''
const flow = beginOrcaCloudPkceFlow(config, 'profile-1', {
onAuthorizeUrl: (url) => (authorize = url),
authorizeParams: { setup: '1', device: 'MacBook Pro', setup_steps: 'github' },
holdBrowser: true
})
await vi.waitFor(() => expect(authorize).not.toBe(''))
const url = new URL(authorize)
expect(url.searchParams.get('setup')).toBe('1')
expect(url.searchParams.get('device')).toBe('MacBook Pro')
expect(url.searchParams.get('setup_steps')).toBe('github')
const callback = new URL(url.searchParams.get('redirect_uri')!)
callback.searchParams.set('code', 'the-code')
callback.searchParams.set('state', url.searchParams.get('state')!)
const browser = fetch(callback, { redirect: 'manual' })
const code = await flow
expect(code.code).toBe('the-code')
expect(code.finishBrowser).toBeTypeOf('function')
code.finishBrowser!('https://auth.test/cloud/setup/start?session=cs_x&ticket=t')
const response = await browser
expect(response.status).toBe(302)
expect(response.headers.get('location')).toBe(
'https://auth.test/cloud/setup/start?session=cs_x&ticket=t'
)
})
it('shows the signed-in page when setup has nowhere to go (or an unsafe URL)', async () => {
process.env.ORCA_CLOUD_DEV_OPEN_URL_FILE = join(mkdtempSync(join(tmpdir(), 'pkce-')), 'urls')
let authorize = ''
const flow = beginOrcaCloudPkceFlow(config, 'profile-1', {
onAuthorizeUrl: (url) => (authorize = url),
holdBrowser: true
})
await vi.waitFor(() => expect(authorize).not.toBe(''))
const url = new URL(authorize)
const callback = new URL(url.searchParams.get('redirect_uri')!)
callback.searchParams.set('code', 'c')
callback.searchParams.set('state', url.searchParams.get('state')!)
const browser = fetch(callback, { redirect: 'manual' })
;(await flow).finishBrowser!('javascript:alert(1)')
expect((await browser).status).toBe(200)
})
})
+48 -10
View File
@@ -14,8 +14,16 @@ export type OrcaCloudAuthorizationCode = {
nonce: string
redirectUri: string
state: string
/**
* Only with `holdBrowser`: finishes the browser tab, either sending it on to `location` (cloud
* setup continues in the same tab) or showing the usual "signed in" page when null.
*/
finishBrowser?: (location: string | null) => void
}
/** How long a held browser tab waits for the caller before it gets the "signed in" page. */
const HOLD_BROWSER_MS = 30_000
const AUTH_TIMEOUT_MS = 5 * 60 * 1000
function base64Url(buffer: Buffer): string {
@@ -43,7 +51,14 @@ function closeServer(server: Server): void {
export function beginOrcaCloudPkceFlow(
config: OrcaCloudAuthConfig,
localProfileId: string,
options: { onAuthorizeUrl?: (url: string) => void; signal?: AbortSignal } = {}
options: {
onAuthorizeUrl?: (url: string) => void
signal?: AbortSignal
/** Extra authorize parameters (cloud setup: setup=1, device, setup_steps). */
authorizeParams?: Record<string, string>
/** Keep the browser's callback request open until the caller calls finishBrowser. */
holdBrowser?: boolean
} = {}
): Promise<OrcaCloudAuthorizationCode> {
const codeVerifier = createCodeVerifier()
const nonce = base64Url(randomBytes(32))
@@ -62,19 +77,35 @@ export function beginOrcaCloudPkceFlow(
closeServer(server)
}
function resolveFlow(code: string): void {
function resolveFlow(code: string, held?: ServerResponse): void {
if (settled) {
return
}
settled = true
resolve({
code,
codeVerifier,
nonce,
redirectUri,
state
})
closeServer(server)
if (!held) {
resolve({ code, codeVerifier, nonce, redirectUri, state })
closeServer(server)
return
}
let finished = false
const finishBrowser = (location: string | null): void => {
if (finished) {
return
}
finished = true
clearTimeout(holdTimer)
// Only an https page may follow a sign-in in the same tab.
if (location && location.startsWith('https://')) {
held.writeHead(302, { location, 'cache-control': 'no-store' })
held.end()
} else {
held.writeHead(200, ORCA_CLOUD_CALLBACK_RESPONSE_HEADERS)
held.end(ORCA_CLOUD_CALLBACK_SUCCESS_PAGE)
}
closeServer(server)
}
const holdTimer = setTimeout(() => finishBrowser(null), HOLD_BROWSER_MS)
resolve({ code, codeVerifier, nonce, redirectUri, state, finishBrowser })
}
function writeInvalidCallback(response: ServerResponse): void {
@@ -114,6 +145,10 @@ export function beginOrcaCloudPkceFlow(
writeInvalidCallback(response)
return
}
if (options.holdBrowser) {
resolveFlow(code, response)
return
}
response.writeHead(200, ORCA_CLOUD_CALLBACK_RESPONSE_HEADERS)
response.end(ORCA_CLOUD_CALLBACK_SUCCESS_PAGE)
resolveFlow(code)
@@ -149,6 +184,9 @@ export function beginOrcaCloudPkceFlow(
authorizeUrl.searchParams.set('code_challenge', createCodeChallenge(codeVerifier))
authorizeUrl.searchParams.set('code_challenge_method', 'S256')
authorizeUrl.searchParams.set('local_profile_id', localProfileId)
for (const [key, value] of Object.entries(options.authorizeParams ?? {})) {
authorizeUrl.searchParams.set(key, value)
}
options.onAuthorizeUrl?.(authorizeUrl.toString())
// Dev automation only (unpackaged): hand the sign-in URL to a test driver instead of
// opening the developer's own browser. Same pattern as ORCA_BILLING_DEV_OPEN_URL_FILE.
@@ -67,8 +67,18 @@ export function getCurrentOrcaProfileAuthStatus(userDataPath: string): OrcaProfi
return getOrcaProfileAuthStatusFromProfile(ensureActiveOrcaProfile(userDataPath), userDataPath)
}
/**
* Cloud setup sign-in: the authorize page shows the setup account step (A2), and once signed in
* the same browser tab continues to whatever `afterSignIn` returns (the setup session's URL).
*/
export type OrcaCloudSetupSignIn = {
authorizeParams: Record<string, string>
afterSignIn: () => Promise<string | null>
}
export async function connectCurrentOrcaProfile(
userDataPath: string
userDataPath: string,
setup?: OrcaCloudSetupSignIn
): Promise<ConnectCurrentOrcaProfileResult> {
const active = ensureActiveOrcaProfile(userDataPath)
if (isOrcaCloudDevAuthEnabled()) {
@@ -92,11 +102,14 @@ export async function connectCurrentOrcaProfile(
const attempt = ++nextCloudConnectAttempt
const browserWait = new AbortController()
startOrcaCloudSignInProgress(attempt, () => browserWait.abort())
let finishBrowser: ((location: string | null) => void) | undefined
try {
const code = await beginOrcaCloudPkceFlow(configState.config, active.profile.id, {
signal: browserWait.signal,
onAuthorizeUrl: (link) => setOrcaCloudSignInLink(attempt, link)
onAuthorizeUrl: (link) => setOrcaCloudSignInLink(attempt, link),
...(setup ? { authorizeParams: setup.authorizeParams, holdBrowser: true } : {})
})
finishBrowser = code.finishBrowser
// The callback listener has closed, so its browser link is dead.
setOrcaCloudSignInLink(attempt, null)
if (attempt < linkedCloudConnectAttempt) {
@@ -106,7 +119,11 @@ export async function connectCurrentOrcaProfile(
}
}
const exchange = await exchangeOrcaCloudAuthCode(configState.config, {
...code,
code: code.code,
codeVerifier: code.codeVerifier,
nonce: code.nonce,
redirectUri: code.redirectUri,
state: code.state,
localProfileId: active.profile.id
})
if (attempt < linkedCloudConnectAttempt) {
@@ -118,6 +135,11 @@ export async function connectCurrentOrcaProfile(
signInCloudSession(active.profile.id, userDataPath, exchange)
const list = linkOrcaProfileToCloud(active.profile.id, exchange.cloud, userDataPath)
linkedCloudConnectAttempt = attempt
if (setup && finishBrowser) {
const next = await setup.afterSignIn().catch(() => null)
finishBrowser(next)
finishBrowser = undefined
}
return {
status: 'connected',
auth: getCurrentOrcaProfileAuthStatus(userDataPath),
@@ -148,6 +170,7 @@ export async function connectCurrentOrcaProfile(
error: message
}
} finally {
finishBrowser?.(null)
endOrcaCloudSignInProgress(attempt)
}
}
+12
View File
@@ -1,3 +1,9 @@
import type {
CloudSetupGetResult,
CloudSetupLinkResult,
CloudSetupStartArgs,
CloudSetupStartResult
} from '../../shared/orca-cloud-setup'
import type {
OrcaProfileOrgCreateArgs,
OrcaProfileOrgCreateResult,
@@ -95,6 +101,12 @@ export type OrcaProfileApi = {
billingStatus: () => Promise<OrcaBillingStatusResult>
/** Opens hosted Stripe Checkout in the browser. */
billingOpenCheckout: (args: OrcaBillingCheckoutArgs) => Promise<OrcaBillingOpenResult>
/** Starts Orca Cloud setup: one browser tab for sign-in, team, plan and GitHub. */
cloudSetupStart: (args: CloudSetupStartArgs) => Promise<CloudSetupStartResult>
/** The setup session's steps, for the composer's setup panel. */
cloudSetupGet: (args: { sessionId: string }) => Promise<CloudSetupGetResult>
/** "Copy setup link": a fresh one-time link to the same setup session. */
cloudSetupLink: (args: { sessionId: string }) => Promise<CloudSetupLinkResult>
/** Opens the Stripe Customer Portal in the browser. */
billingOpenPortal: () => Promise<OrcaBillingOpenResult>
/** Plan state for other teams the user is on ("Switch to <team>"); never switches teams. */
+3
View File
@@ -87,5 +87,8 @@ export const orcaProfilesApi = {
billingOpenCheckout: (args) => ipcRenderer.invoke('orcaProfiles:billingOpenCheckout', args),
billingOpenPortal: () => ipcRenderer.invoke('orcaProfiles:billingOpenPortal'),
billingTeamPlans: (args) => ipcRenderer.invoke('orcaProfiles:billingTeamPlans', args),
cloudSetupStart: (args) => ipcRenderer.invoke('orcaProfiles:cloudSetupStart', args),
cloudSetupGet: (args) => ipcRenderer.invoke('orcaProfiles:cloudSetupGet', args),
cloudSetupLink: (args) => ipcRenderer.invoke('orcaProfiles:cloudSetupLink', args),
billingSetOverage: (args) => ipcRenderer.invoke('orcaProfiles:billingSetOverage', args)
} satisfies PreloadApi['orcaProfiles']
@@ -2,6 +2,10 @@ import { useCallback, useEffect, useRef, useState } from 'react'
import type { OrcaBillingOpenResult } from '../../../../../shared/orca-billing'
import { getBillingGeneration, recordBillingStatusIfCurrent } from '../billing-summary-store'
import { installWindowVisibilityInterval } from '@/lib/window-visibility-interval'
import {
activeCloudSetupSessionId,
startCloudSetupSession
} from '@/lib/orca-cloud/cloud-setup-session'
import {
CHECKOUT_POLL_MS,
CHECKOUT_SLOW_POLL_MS,
@@ -42,12 +46,28 @@ export function useCheckoutFlow({ onPaid }: { onPaid: (seats: number) => void })
const start = useCallback((order: CheckoutOrder) => {
const id = ++runId.current
setPhase({ kind: 'opening', order })
// Joins an open setup session, so Checkout returns to its next step (T2 Compare plans).
const setupSessionId = activeCloudSetupSessionId()
void window.api.orcaProfiles
.billingOpenCheckout({ plan: 'team', interval: order.interval, seats: order.seats })
.billingOpenCheckout({
plan: 'team',
interval: order.interval,
seats: order.seats,
...(setupSessionId ? { setupSessionId } : {})
})
.catch((error: unknown): OrcaBillingOpenResult => ({
status: 'failed',
error: String(error)
}))
.then(async (result): Promise<OrcaBillingOpenResult> => {
if (result.status !== 'team-required') {
return result
}
// O1: a plan always lands on a team. The browser makes or picks the team, then Checkout;
// the setup session switches this profile to that team when it's there.
const started = await startCloudSetupSession({ needs: ['team', 'plan'], chooseTeam: true })
return started ? { status: 'opened' } : result
})
.then((result) => {
if (id === runId.current) {
setPhase(nextPhaseAfterOpen(order, result, Date.now()))
@@ -97,6 +97,11 @@ export function openFailureCopy(result: OrcaBillingOpenResult, t: Translate): st
'auto.components.billing.openAlreadySubscribed',
'This account already has a plan. Use Manage billing to change it.'
)
case 'team-required':
return t(
'auto.components.billing.openTeamRequired',
'Plans belong to a team. Create a team, then choose a plan.'
)
case 'no-billing-account':
return t(
'auto.components.billing.openNoAccount',
+1
View File
@@ -20700,6 +20700,7 @@
"capUsedLabel": "Overage spend cap used",
"enterpriseContactSales": "Contact sales",
"openForbidden2": "Only an owner or admin can manage billing.",
"openTeamRequired": "Plans belong to a team. Create a team, then choose a plan.",
"openSignedOut2": "Sign in to Orca again to manage your team.",
"overageDescription7": "Optional overage at {{rate}} per sandbox hour, billed by the minute, up to a monthly spend cap you set ({{cap}} by default).",
"overageMemberHint": "Owners and admins can change overage.",
@@ -0,0 +1,136 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
const selectOrcaProfileOrg = vi.hoisted(() => vi.fn(async () => undefined))
const storeState = vi.hoisted(() => ({
orcaProfileAuthStatus: { cloud: { activeOrgId: undefined as string | undefined } },
selectOrcaProfileOrg
}))
vi.mock('@/store', () => ({ useAppStore: { getState: () => storeState } }))
import type { CloudSetupSession } from '../../../../shared/orca-cloud-setup'
import {
SETUP_FAST_POLL_MS,
activeCloudSetupSessionId,
getCloudSetupSnapshot,
refreshCloudSetupSession,
resetCloudSetupSessionsForTests,
snapshotFromSession,
startCloudSetupSession,
subscribeCloudSetupSessions
} from './cloud-setup-session'
const ID = 'cs_AAAAAAAAAAAAAAAAAAAAAA'
function session(overrides: Partial<CloudSetupSession> = {}): CloudSetupSession {
return {
id: ID,
steps: [
{ id: 'account', state: 'done' },
{ id: 'team', state: 'active' },
{ id: 'github', state: 'pending' }
],
team: null,
trial: null,
plan: null,
finished: false,
error: null,
expiresAt: Date.now() + 3600_000,
...overrides
}
}
const cloudSetupStart = vi.fn()
const cloudSetupGet = vi.fn()
beforeEach(() => {
vi.useFakeTimers()
cloudSetupStart.mockReset()
cloudSetupGet.mockReset()
selectOrcaProfileOrg.mockClear()
storeState.orcaProfileAuthStatus.cloud.activeOrgId = undefined
vi.stubGlobal(
'window',
Object.assign(globalThis, { api: { orcaProfiles: { cloudSetupStart, cloudSetupGet } } })
)
})
afterEach(() => {
resetCloudSetupSessionsForTests()
vi.useRealTimers()
})
describe('cloud setup session (renderer)', () => {
it('maps a session to panel rows with the team name as detail', () => {
const snapshot = snapshotFromSession(
session({
steps: [
{ id: 'account', state: 'done' },
{ id: 'team', state: 'done' },
{ id: 'plan', state: 'done', detail: 'trial' }
],
team: { orgId: 'org_1', name: 'acme', created: true },
finished: true
})
)
expect(snapshot.steps).toEqual([
{ id: 'account', state: 'done' },
{ id: 'team', state: 'done', detail: 'acme' },
{ id: 'plan', state: 'done', detail: 'trial' }
])
expect(snapshot.finished).toBe(true)
expect(snapshot.error).toBeUndefined()
})
it('starts, polls every 2 s, follows the new team, and stops when finished', async () => {
cloudSetupStart.mockResolvedValue({ status: 'opened', sessionId: ID, expiresAt: 0 })
cloudSetupGet.mockResolvedValueOnce({ status: 'ok', session: session() })
const seen: string[] = []
subscribeCloudSetupSessions((id) => seen.push(id))
expect(
await startCloudSetupSession({ repo: 'https://github.com/acme/web', needs: ['github'] })
).toEqual({
sessionId: ID
})
expect(cloudSetupStart).toHaveBeenCalledWith({
repo: 'https://github.com/acme/web',
needs: ['github']
})
await vi.advanceTimersByTimeAsync(0)
expect(getCloudSetupSnapshot(ID)?.steps[1]).toEqual({ id: 'team', state: 'active' })
expect(activeCloudSetupSessionId()).toBe(ID)
cloudSetupGet.mockResolvedValueOnce({
status: 'ok',
session: session({
steps: [
{ id: 'account', state: 'done' },
{ id: 'team', state: 'done' },
{ id: 'github', state: 'done' }
],
team: { orgId: 'org_new', name: 'acme', created: true },
finished: true
})
})
await vi.advanceTimersByTimeAsync(SETUP_FAST_POLL_MS)
expect(selectOrcaProfileOrg).toHaveBeenCalledWith('org_new')
expect(getCloudSetupSnapshot(ID)?.finished).toBe(true)
expect(seen).toEqual([ID, ID])
expect(activeCloudSetupSessionId()).toBeNull()
// Finished: no more polls.
await vi.advanceTimersByTimeAsync(SETUP_FAST_POLL_MS * 3)
expect(cloudSetupGet).toHaveBeenCalledTimes(2)
})
it('stops on an expired session and returns null when setup cannot open', async () => {
cloudSetupStart.mockResolvedValueOnce({ status: 'signed-out' })
expect(await startCloudSetupSession({ needs: ['plan'] })).toBeNull()
cloudSetupGet.mockResolvedValue({ status: 'not-found' })
await refreshCloudSetupSession(ID)
expect(getCloudSetupSnapshot(ID)).toBeNull()
await vi.advanceTimersByTimeAsync(SETUP_FAST_POLL_MS * 2)
expect(cloudSetupGet).toHaveBeenCalledTimes(1)
})
})
@@ -0,0 +1,216 @@
// Orca Cloud setup session (NP-4 N1), renderer side: starts the one-tab browser setup, polls the
// session while it is open, and keeps the latest snapshot for the composer's setup panel
// (w2-lifecycle's seam reads it synchronously) and the setup tracker (np4-shell).
import { useAppStore } from '@/store'
import { onCloudSetupReturn } from './cloud-setup-return'
import type {
CloudSetupNeed,
CloudSetupSession,
CloudSetupStartResult
} from '../../../../shared/orca-cloud-setup'
/** Poll every 2 s for the first 3 minutes, then every 10 s (spec A6). */
export const SETUP_FAST_POLL_MS = 2_000
export const SETUP_FAST_WINDOW_MS = 3 * 60_000
export const SETUP_SLOW_POLL_MS = 10_000
export type CloudSetupRowId = 'account' | 'team' | 'plan' | 'github'
/** One row of the setup panel; the same shape as the composer's CloudSetupStep for these ids. */
export type CloudSetupSnapshotStep = {
id: CloudSetupRowId
state: 'done' | 'needed' | 'active' | 'pending' | 'failed' | 'optional'
detail?: string
}
export type CloudSetupSnapshot = {
steps: CloudSetupSnapshotStep[]
finished: boolean
error?: { kind: string; detail?: string }
team: CloudSetupSession['team']
trial: CloudSetupSession['trial']
plan: CloudSetupSession['plan']
}
/**
* Session -> panel rows. Every required row is present (account, team, plan, github when asked),
* because a snapshot replaces the composer's own rows. `detail` carries the team name, how the
* plan is covered ('trial' | 'subscription' | 'checkout') and 'requested' for a pending GitHub
* approval.
*/
export function snapshotFromSession(session: CloudSetupSession): CloudSetupSnapshot {
const steps = session.steps.map((step): CloudSetupSnapshotStep => {
const detail = step.id === 'team' ? (session.team?.name ?? step.detail) : step.detail
return { id: step.id, state: step.state, ...(detail ? { detail } : {}) }
})
return {
steps,
finished: session.finished,
...(session.error ? { error: session.error } : {}),
team: session.team,
trial: session.trial,
plan: session.plan
}
}
type Entry = {
snapshot: CloudSetupSnapshot | null
startedAt: number
timer: number | null
inFlight: boolean
gone: boolean
/** The team the profile was switched to for this session (once). */
switchedTo: string | null
}
const entries = new Map<string, Entry>()
const listeners = new Set<(sessionId: string) => void>()
function emit(sessionId: string): void {
for (const listener of listeners) {
listener(sessionId)
}
}
/** Latest known state of a session, or null before the first poll answers. */
export function getCloudSetupSnapshot(sessionId: string): CloudSetupSnapshot | null {
return entries.get(sessionId)?.snapshot ?? null
}
export function subscribeCloudSetupSessions(listener: (sessionId: string) => void): () => void {
listeners.add(listener)
return () => listeners.delete(listener)
}
function schedule(sessionId: string, entry: Entry): void {
if (entry.timer !== null) {
window.clearTimeout(entry.timer)
}
if (entry.gone || entry.snapshot?.finished) {
entry.timer = null
return
}
const delay =
Date.now() - entry.startedAt < SETUP_FAST_WINDOW_MS ? SETUP_FAST_POLL_MS : SETUP_SLOW_POLL_MS
entry.timer = window.setTimeout(() => void refreshCloudSetupSession(sessionId), delay)
}
/**
* Setup chose or created a team in the browser: make it this profile's active team, so billing,
* sandboxes and the composer's checks all read that team (O1: cloud work belongs to a team).
*/
async function followSetupTeam(entry: Entry, session: CloudSetupSession): Promise<void> {
const orgId = session.team?.orgId
if (!orgId || entry.switchedTo === orgId) {
return
}
entry.switchedTo = orgId
const state = useAppStore.getState()
if (state.orcaProfileAuthStatus?.cloud?.activeOrgId !== orgId) {
await state.selectOrcaProfileOrg(orgId)
}
}
/** Polls now (the orca://cloud/setup/return link and window focus call this). */
export async function refreshCloudSetupSession(sessionId: string): Promise<void> {
const entry = entries.get(sessionId) ?? watchCloudSetupSession(sessionId)
if (entry.inFlight || entry.gone) {
return
}
entry.inFlight = true
try {
const result = await window.api.orcaProfiles.cloudSetupGet({ sessionId })
if (result.status === 'ok') {
entry.snapshot = snapshotFromSession(result.session)
await followSetupTeam(entry, result.session)
emit(sessionId)
} else if (result.status === 'not-found') {
// Expired or another account's: stop polling; the composer falls back to its own rows.
entry.gone = true
entry.snapshot = null
emit(sessionId)
}
} catch {
// Offline or main busy: keep the last snapshot and try again on the next tick.
} finally {
entry.inFlight = false
schedule(sessionId, entry)
}
}
let disposeReturnLink: (() => void) | null = null
/** Starts polling a session (e.g. one restored from the on-disk draft after a restart). */
export function watchCloudSetupSession(sessionId: string): Entry {
// The done page's orca://cloud/setup/return link polls at once instead of on the next tick.
disposeReturnLink ??= onCloudSetupReturn((returned) => {
if (entries.has(returned)) {
void refreshCloudSetupSession(returned)
}
})
let entry = entries.get(sessionId)
if (!entry) {
entry = {
snapshot: null,
startedAt: Date.now(),
timer: null,
inFlight: false,
gone: false,
switchedTo: null
}
entries.set(sessionId, entry)
window.setTimeout(() => void refreshCloudSetupSession(sessionId), 0)
}
return entry
}
export function stopWatchingCloudSetupSession(sessionId: string): void {
const entry = entries.get(sessionId)
if (entry?.timer != null) {
window.clearTimeout(entry.timer)
}
entries.delete(sessionId)
}
/** "Set up and start": opens the one browser tab and starts polling. Null when it couldn't. */
export async function startCloudSetupSession(request: {
repo?: string
needs: CloudSetupNeed[]
chooseTeam?: boolean
}): Promise<{ sessionId: string } | null> {
let result: CloudSetupStartResult
try {
result = await window.api.orcaProfiles.cloudSetupStart({
...(request.repo ? { repo: request.repo } : {}),
needs: request.needs,
...(request.chooseTeam ? { chooseTeam: true } : {})
})
} catch {
return null
}
if (result.status !== 'opened') {
return null
}
watchCloudSetupSession(result.sessionId)
return { sessionId: result.sessionId }
}
/** The setup session still open in this window, for the plans dialog to join (T2 Compare plans). */
export function activeCloudSetupSessionId(): string | null {
for (const [sessionId, entry] of entries) {
if (!entry.gone && !entry.snapshot?.finished) {
return sessionId
}
}
return null
}
/** Test-only. */
export function resetCloudSetupSessionsForTests(): void {
for (const sessionId of entries.keys()) {
stopWatchingCloudSetupSession(sessionId)
}
listeners.clear()
disposeReturnLink?.()
disposeReturnLink = null
}
@@ -77,6 +77,9 @@ export function createWebOrcaProfilesApi(): Partial<PreloadApi> {
onCloudSetupReturn: () => () => {},
billingStatus: async () => ({ status: 'unconfigured' }),
billingOpenCheckout: async () => ({ status: 'unconfigured' }),
cloudSetupStart: async () => ({ status: 'unconfigured' }),
cloudSetupGet: async () => ({ status: 'unconfigured' }),
cloudSetupLink: async () => ({ status: 'unconfigured' }),
billingOpenPortal: async () => ({ status: 'unconfigured' }),
billingTeamPlans: async () => ({ status: 'unconfigured' }),
billingSetOverage: async () => ({ status: 'unconfigured' })
+4
View File
@@ -128,6 +128,8 @@ export type OrcaBillingCheckoutArgs = {
plan: OrcaBillingPlanId
interval: OrcaBillingInterval
seats: number
/** The plans dialog joins an open cloud setup session: Checkout then returns to its next step. */
setupSessionId?: string
}
export type OrcaBillingOverageArgs = {
@@ -143,6 +145,8 @@ export type OrcaBillingOpenResult =
| { status: 'forbidden' }
| { status: 'already-subscribed' }
| { status: 'no-billing-account' }
/** Personal account: every plan lands on a team, so the caller starts cloud setup instead. */
| { status: 'team-required' }
| { status: 'failed'; error: string }
export type OrcaBillingOverageResult =
+69
View File
@@ -0,0 +1,69 @@
// Orca Cloud setup session (NP-4 N1): one browser tab that chains sign-in, team, plan or trial,
// Checkout (only when needed) and the GitHub App install. The billing service owns the session;
// the desktop starts it and polls it while the composer's setup panel shows each step.
export const CLOUD_SETUP_NEEDS = ['team', 'plan', 'github'] as const
export type CloudSetupNeed = (typeof CLOUD_SETUP_NEEDS)[number]
export const CLOUD_SETUP_SESSION_ID = /^cs_[A-Za-z0-9_-]{22}$/
export type CloudSetupStartArgs = {
/** https://github.com/<owner>/<repo> of the project, when the workspace needs GitHub access. */
repo?: string
needs: CloudSetupNeed[]
/** Ask which team even when the profile already has an active one. */
chooseTeam?: boolean
}
export type CloudSetupStartResult =
| { status: 'opened'; sessionId: string; expiresAt: number }
| { status: 'unconfigured' }
| { status: 'signed-out' }
| { status: 'cancelled' }
| { status: 'failed'; error: string }
export type CloudSetupStepState = 'done' | 'needed' | 'active' | 'pending' | 'failed' | 'optional'
export type CloudSetupSessionStep = {
id: 'account' | 'team' | 'plan' | 'github'
state: CloudSetupStepState
/** team: its name · plan: 'trial' | 'subscription' | 'checkout' · github: 'requested'. */
detail?: string
}
/** Error kinds the setup tracker shows (spec X1); `detail` carries e.g. the other account's email. */
export const CLOUD_SETUP_ERROR_KINDS = [
'timed_out',
'checkout_canceled',
'bank_step',
'trial_unavailable',
'team_create_failed',
'wrong_account'
] as const
export type CloudSetupErrorKind = (typeof CLOUD_SETUP_ERROR_KINDS)[number]
export type CloudSetupSession = {
id: string
steps: CloudSetupSessionStep[]
team: { orgId: string; name: string | null; created: boolean } | null
trial: { includedSeconds: number; usedSeconds: number; exhausted: boolean } | null
plan: 'subscription' | 'trial' | null
finished: boolean
error: { kind: CloudSetupErrorKind; detail?: string } | null
expiresAt: number
}
export type CloudSetupGetResult =
| { status: 'ok'; session: CloudSetupSession }
/** Expired, or it belongs to another account. */
| { status: 'not-found' }
| { status: 'unconfigured' }
| { status: 'signed-out' }
| { status: 'failed'; error: string }
export type CloudSetupLinkResult =
| { status: 'ok'; url: string }
| { status: 'not-found' }
| { status: 'unconfigured' }
| { status: 'signed-out' }
| { status: 'failed'; error: string }