Merge remote-tracking branch 'private/cloud/integration' into cloud/clone-access-error

# Conflicts:
#	src/renderer/src/lib/orca-cloud/cloud-glossary-allowlist.json
This commit is contained in:
Neil
2026-11-13 00:58:57 -08:00
152 changed files with 5110 additions and 1383 deletions
+1 -1
View File
@@ -129,7 +129,7 @@ type AccountState = {
export { entitlementsMode, type EntitlementsMode } from './entitlements-mode'
const LIVE_STATUSES = new Set(['active', 'trialing'])
export const LIVE_STATUSES = new Set(['active', 'trialing'])
export function subscriptionWindow(subscription: SubscriptionRow, at: number): { start: number; end: number } {
return allowanceWindow({ start: subscription.current_period_start, end: subscription.current_period_end }, at)
+19 -1
View File
@@ -5,13 +5,19 @@
// live grants in every mode but 'off' (where nothing projects grants, so nothing is on). The
// legacy computation has no features, so there is nothing for shadow mode to compare.
//
// POST /v1/internal/entitlements/features {accountId} -> { features: { audit_log, sso, scim, mfa_enforcement } }
// POST /v1/internal/entitlements/features {accountId}
// -> { features: { audit_log, sso, scim, mfa_enforcement }, subscribed }
// `subscribed` (hasPaidSubscription) is what auth counts as Orca Cloud access for the account, so a
// paying team is never sent to "Choose a Team plan" because it isn't on the per-account rollout.
// Callers: the control plane (CONTROL_PLANE_TOKEN) and auth (MEMBERSHIP_SYNC_TOKEN). Both fail closed.
import { z } from 'zod'
import { FEATURE_KEYS, type FeatureFlags } from './entitlement-keys'
import { entitlementsMode } from './entitlements-mode'
import type { Env } from './env'
import { LIVE_STATUSES } from './entitlements'
import { grantsForSubject, liveAt } from './grants'
import { currentSubscription } from './store'
import { PAYMENT_FAILED_STATUSES } from './webhook'
export const FeaturesRequestSchema = z.object({ accountId: z.string().min(1).max(160).regex(/^[A-Za-z0-9_.:-]+$/) }).strict()
@@ -35,3 +41,15 @@ export async function featuresFor(env: Pick<Env, 'BILLING_DB' | 'ENTITLEMENTS_MO
}
return flags
}
/**
* Whether the account holds a paid subscription that is live (active, trialing) or in payment
* recovery (past_due, unpaid): a paying customer, whatever its hours or payment state, whose
* problems the entitlement itself reports. Canceled, incomplete and expired subscriptions, the
* no-card trial and no subscription at all are false. Independent of ENTITLEMENTS_MODE: it reads
* the subscription row Stripe's webhooks keep, as the legacy entitlement does.
*/
export async function hasPaidSubscription(db: D1Database, accountId: string): Promise<boolean> {
const subscription = await currentSubscription(db, accountId)
return subscription !== null && (LIVE_STATUSES.has(subscription.status) || PAYMENT_FAILED_STATUSES.has(subscription.status))
}
+7 -3
View File
@@ -15,7 +15,7 @@
// POST /v1/stripe/webhook signed events
// Sandbox control plane (CONTROL_PLANE_TOKEN):
// POST /v1/internal/entitlements/check {accountId, machineSize, runningSandboxes}
// POST /v1/internal/entitlements/features {accountId} -> {features: {audit_log, sso, scim, mfa_enforcement}} plan feature flags (control plane or auth)
// POST /v1/internal/entitlements/features {accountId} -> {features: {audit_log, sso, scim, mfa_enforcement}, subscribed} plan feature flags and paid-subscription access (control plane or auth)
// POST /v1/internal/usage {usageId, accountId, sandboxId, machineSize, startedAt, endedAt}
// GET /v1/internal/suspensions accounts whose payment grace expired (suspend running)
// POST /v1/internal/trial/github {accountId, githubUserId?, githubOwnerId?} GitHub binding -> trial abuse keys
@@ -58,7 +58,7 @@ import { MACHINE_SIZES, PlanConfigError, planCatalog, publicOffers } from './pla
import { OverageRequestSchema, updateOverage } from './overage'
import { LiveModeRefusedError, StripeError, createStripeClient, type StripeClient } from './stripe'
import { UsageReportSchema, flushMeterReports, recordUsage, validateSegment } from './usage'
import { FeaturesRequestSchema, featuresFor } from './features'
import { FeaturesRequestSchema, featuresFor, hasPaidSubscription } from './features'
import { handleStripeWebhook } from './webhook'
import { UsageHistoryQuerySchema, usageHistory } from './usage-history'
import { renderReturnPage, returnOutcome } from './return-page'
@@ -526,7 +526,11 @@ export async function handleRequest(request: Request, env: Env, ctx: ExecutionCo
if (!body.success) {
return json({ error: 'invalid_request' }, 400)
}
return json({ features: await featuresFor(env, body.data.accountId, now) })
const [features, subscribed] = await Promise.all([
featuresFor(env, body.data.accountId, now),
hasPaidSubscription(env.BILLING_DB, body.data.accountId)
])
return json({ features, subscribed })
}
case 'POST /v1/internal/usage': {
+45 -4
View File
@@ -7,6 +7,7 @@ import { featuresFor } from '../src/features'
import { grantContactSalesPlan, grantsForSource, revokeManualGrant } from '../src/grants'
import { repoCatalog } from './catalog-fixture'
import { createHarness } from './harness'
import { checkoutCompleted } from './stripe-fake'
const ALL_OFF = { audit_log: false, sso: false, scim: false, mfa_enforcement: false }
const ALL_ON = { audit_log: true, sso: true, scim: true, mfa_enforcement: true }
@@ -50,11 +51,11 @@ describe('catalog', () => {
describe.each(['shadow', 'on'])('features (ENTITLEMENTS_MODE=%s)', (mode) => {
it('are off for a team without Enterprise and on for one granted the plan', async () => {
const h = await createHarness({ ENTITLEMENTS_MODE: mode })
expect((await features(h)).body).toEqual({ features: ALL_OFF })
expect((await features(h)).body).toEqual({ features: ALL_OFF, subscribed: false })
expect(await enterprise(h)).toEqual({ changed: true, planVersion: 2 })
expect((await features(h)).body).toEqual({ features: ALL_ON })
expect((await features(h)).body).toEqual({ features: ALL_ON, subscribed: false })
// Another team is unaffected.
expect((await features(h, 'org:o2')).body).toEqual({ features: ALL_OFF })
expect((await features(h, 'org:o2')).body).toEqual({ features: ALL_OFF, subscribed: false })
})
it('the grant names the real plan and version, and stops when it ends or is revoked', async () => {
@@ -76,7 +77,7 @@ describe('features', () => {
const h = await createHarness({ ENTITLEMENTS_MODE: 'shadow' })
await enterprise(h)
h.env.ENTITLEMENTS_MODE = 'off'
expect((await features(h)).body).toEqual({ features: ALL_OFF })
expect((await features(h)).body).toEqual({ features: ALL_OFF, subscribed: false })
})
it('only a contact-sales plan can be granted this way', async () => {
@@ -121,3 +122,43 @@ describe('features', () => {
expect(body.grants.find((grant: { key: string }) => grant.key === 'audit_log')).toMatchObject({ value: true, source: 'manual', plan: { id: 'enterprise', version: 2 }, state: 'active' })
})
})
describe('subscribed', () => {
const PERIOD_START = Math.floor(Date.now() / 1000) - 5 * 24 * 3600
const PERIOD_END = PERIOD_START + 30 * 24 * 3600
// A paid Team subscription for org:o1, through checkout and Stripe's webhook as in production.
async function paidTeam(mode = 'shadow') {
const h = await createHarness({ ENTITLEMENTS_MODE: mode })
const token = await h.desktopToken({ sub: 'u1', org: 'o1', orgRole: 'owner', email: 'a@example.com' })
const checkout = await h.call('POST', '/v1/billing/checkout', { body: { plan: 'team', seats: 2 }, headers: { authorization: `Bearer ${token}` } })
expect(checkout.status).toBe(200)
const customer = [...h.stripe.customers.keys()][0]!
const subscription = h.stripe.putSubscription({ customer, accountId: 'org:o1', basePrice: 'price_team_month', quantity: 2, periodStart: PERIOD_START, periodEnd: PERIOD_END })
await h.webhook(checkoutCompleted({ customer, subscription: subscription.id, accountId: 'org:o1' }))
return h
}
const setStatus = (h: Awaited<ReturnType<typeof createHarness>>, status: string) => h.raw.prepare('UPDATE subscriptions SET status = ? WHERE account_id = ?').run(status, 'org:o1')
it('is true for a team paying for a plan, whatever its hours, and false for everyone else', async () => {
for (const mode of ['off', 'shadow', 'on']) {
const h = await paidTeam(mode)
expect((await features(h)).body).toMatchObject({ subscribed: true })
// Another team, and the owner's personal account, have no subscription.
expect((await features(h, 'org:o2')).body).toMatchObject({ subscribed: false })
expect((await features(h, 'user:u1')).body).toMatchObject({ subscribed: false })
}
})
it('stays true while a payment is being retried, and ends with the subscription', async () => {
const h = await paidTeam()
for (const status of ['trialing', 'past_due', 'unpaid']) {
setStatus(h, status)
expect((await features(h)).body, status).toMatchObject({ subscribed: true })
}
for (const status of ['canceled', 'incomplete', 'incomplete_expired', 'paused']) {
setStatus(h, status)
expect((await features(h)).body, status).toMatchObject({ subscribed: false })
}
})
})
+17 -5
View File
@@ -188,12 +188,18 @@ function repoOwner(accountId: string, repo: string): string {
return `${accountId}#${repo}`
}
/** The owners whose secrets a sandbox session receives. */
export function ownersForSandbox(row: Pick<SandboxRow, 'account_id' | 'user_id' | 'repo_url'>) {
/**
* The owners whose secrets a sandbox session receives.
* SEC-5: a workspace shared with teammates runs their shells too, so anything in its env is theirs to
* read (and a placeholder is theirs to spend). It gets the team's and the repository's secrets only,
* never its owner's personal ones, the same rule as personal accounts (D13). Fails closed: only a row
* known to be private counts as unshared.
*/
export function ownersForSandbox(row: Pick<SandboxRow, 'account_id' | 'user_id' | 'repo_url' | 'visibility'>) {
const repo = normalizeRepo(row.repo_url)
return {
org: ORG_ACCOUNT.test(row.account_id) ? row.account_id : null,
personal: personalOwner(row.user_id, row.account_id.startsWith('dev:')),
personal: row.visibility === 'private' ? personalOwner(row.user_id, row.account_id.startsWith('dev:')) : null,
repo: repo ? repoOwner(row.account_id, repo) : null
}
}
@@ -352,16 +358,22 @@ export type ResolvedSecrets = { env: Record<string, string>; scopes: Record<stri
export async function resolveSandboxSecrets(
db: D1Database,
keyring: Keyring,
row: Pick<SandboxRow, 'id' | 'account_id' | 'user_id' | 'repo_url'>
row: Pick<SandboxRow, 'id' | 'account_id' | 'user_id' | 'repo_url' | 'visibility'>
): Promise<ResolvedSecrets> {
const owners = ownersForSandbox(row)
const pairs: [SecretScope, string][] = [['personal', owners.personal]]
const pairs: [SecretScope, string][] = []
if (owners.personal) {
pairs.push(['personal', owners.personal])
}
if (owners.org) {
pairs.push(['org', owners.org])
}
if (owners.repo) {
pairs.push(['repo', owners.repo])
}
if (pairs.length === 0) {
return { env: {}, scopes: {}, skipped: 0 }
}
const where = pairs.map(() => '(scope = ? AND owner_id = ?)').join(' OR ')
const { results } = await db
.prepare(`SELECT * FROM secrets WHERE ${where}`)
@@ -29,7 +29,7 @@ export type ProviderEnv = { env: Record<string, string>; scopes: Record<string,
export async function resolvedProviderEnv(
db: D1Database,
keyring: Keyring,
row: Pick<SandboxRow, 'id' | 'account_id' | 'user_id' | 'repo_url'>
row: Pick<SandboxRow, 'id' | 'account_id' | 'user_id' | 'repo_url' | 'visibility'>
): Promise<ProviderEnv> {
const { env: stored, scopes } = await resolveSandboxSecrets(db, keyring, row)
// The proxy only needs the keys; dropping those of agents not on 'keep' happens at request time
@@ -45,7 +45,8 @@ const PROVIDER_ENV_CACHE_MS = 60_000
const providerEnvCache = new Map<string, { at: number; value: Promise<ProviderEnv> }>()
export function cachedProviderEnv(db: D1Database, keyring: Keyring, row: SandboxRow, now: number): Promise<ProviderEnv> {
const key = `${row.id}:${row.session_id ?? ''}`
// Visibility is part of the key: sharing a workspace stops its owner's personal keys at once (SEC-5).
const key = `${row.id}:${row.session_id ?? ''}:${row.visibility}`
const hit = providerEnvCache.get(key)
if (hit && now - hit.at < PROVIDER_ENV_CACHE_MS) {
return hit.value
@@ -0,0 +1,216 @@
// SEC-5: a workspace shared with teammates runs their shells too, so nothing personal to its owner may
// be in its env: not a variable's value, and not a placeholder that would spend the owner's model key.
import { SignJWT, createLocalJWKSet, exportJWK, generateKeyPair } from 'jose'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { ENV_COMMAND, START_COMMAND } from '../src/sandbox-vm-commands'
import { ownersForSandbox } from '../src/secrets'
import { createHarness } from './harness'
const KEK = Buffer.alloc(32, 7).toString('base64')
const PROXY_URL = 'https://sandbox.test/v1/egress/proxy'
// Fake values only.
const TEAM_KEY = 'sk-ant-api03-TEAM-fake-0000-aaaa'
const PERSONAL_OPENAI = 'sk-proj-fake-personal-openai-2222'
const PERSONAL_VALUES = [PERSONAL_OPENAI, 'personal-db-password', 'personal-foo-value', 'personal-aws-secret-value']
type Harness = Awaited<ReturnType<typeof createHarness>>
const logs: string[] = []
beforeEach(() => {
logs.length = 0
for (const method of ['log', 'info', 'warn', 'error', 'debug'] as const) {
vi.spyOn(console, method).mockImplementation((...args: unknown[]) => {
logs.push(args.map((arg) => (typeof arg === 'string' ? arg : JSON.stringify(arg))).join(' '))
})
}
})
afterEach(() => {
for (const value of [...PERSONAL_VALUES, TEAM_KEY]) {
expect(logs.join('\n')).not.toContain(value)
}
vi.restoreAllMocks()
})
function decodeEnv(encoded: string | undefined): Record<string, string> {
return Object.fromEntries(
(encoded ?? '')
.split('\n')
.filter(Boolean)
.map((line) => {
const at = line.indexOf('=')
return [line.slice(0, at), Buffer.from(line.slice(at + 1), 'base64').toString('utf8')]
})
)
}
/** The env the VM got at its last boot, or from its last live refresh. */
function vmEnv(h: Harness, command: string = START_COMMAND): Record<string, string> {
return decodeEnv(h.vercel.commands.filter((c) => c.command === command).at(-1)!.env.ORCA_SECRET_ENV)
}
/** Everything the control plane ever sent the VM, as one string: no personal value may be in it. */
function everythingSent(h: Harness, from = 0): string {
return JSON.stringify(
h.vercel.commands.slice(from).map((c) => ({ ...c, env: { ...c.env, ORCA_SECRET_ENV: decodeEnv(c.env.ORCA_SECRET_ENV) } }))
)
}
async function seeded(overrides: Record<string, string> = {}, deps: Parameters<typeof createHarness>[1] = {}) {
const h = await createHarness({ SECRETS_KEK: KEK, ...overrides }, deps)
const admin = await h.token('ada', 'acme', 'sandbox', { orgRole: 'admin' })
const mia = await h.token('mia', 'acme', 'sandbox', { orgRole: 'member' })
const put = (scope: string, name: string, value: string, bearer: string, repo?: string) =>
h.call('PUT', `/v1/secrets/${scope}/${name}${repo ? `?repo=${encodeURIComponent(repo)}` : ''}`, { body: { value }, bearer })
await put('org', 'ANTHROPIC_API_KEY', TEAM_KEY, admin)
await put('org', 'FOO', 'team-foo-value', admin)
await put('repo', 'BAR', 'repo-bar-value', admin, 'acme/app')
await put('personal', 'OPENAI_API_KEY', PERSONAL_OPENAI, mia)
await put('personal', 'DB_PASSWORD', 'personal-db-password', mia)
await put('personal', 'FOO', 'personal-foo-value', mia)
await put('personal', 'AWS_SECRET_ACCESS_KEY', 'personal-aws-secret-value', mia)
const create = (visibility?: 'team' | 'private') =>
h.call('POST', '/v1/sandboxes', {
body: { workspaceId: 'ws-1', machineSize: 'standard', repo: { url: 'https://github.com/acme/app' }, ...(visibility ? { visibility } : {}) },
bearer: mia
})
const share = (id: string, visibility: 'team' | 'private') =>
h.call('PATCH', `/v1/team/workspaces/${id}`, { body: { visibility }, bearer: mia })
return { h, mia, admin, put, create, share }
}
const TEAM_AND_REPO = { ANTHROPIC_API_KEY: TEAM_KEY, BAR: 'repo-bar-value', FOO: 'team-foo-value' }
describe('personal secrets in shared workspaces (SEC-5)', () => {
it('resolves no personal owner for a shared row, and fails closed on an unknown visibility', () => {
const row = { account_id: 'org:acme', user_id: 'mia', repo_url: 'https://github.com/acme/app' }
expect(ownersForSandbox({ ...row, visibility: 'private' }).personal).toBe('user:mia')
expect(ownersForSandbox({ ...row, visibility: 'team' })).toEqual({ org: 'org:acme', personal: null, repo: 'org:acme#github.com/acme/app' })
expect(ownersForSandbox({ ...row, visibility: undefined as never }).personal).toBeNull()
})
it('keeps the owner’s personal secrets in their own private workspace', async () => {
const { h, create } = await seeded()
expect((await create()).status).toBe(200)
expect(vmEnv(h)).toEqual({
...TEAM_AND_REPO,
AWS_SECRET_ACCESS_KEY: 'personal-aws-secret-value',
DB_PASSWORD: 'personal-db-password',
FOO: 'personal-foo-value',
OPENAI_API_KEY: PERSONAL_OPENAI
})
})
it('starts a shared workspace with team and repository secrets only; the team value replaces a personal override', async () => {
const { h, create } = await seeded()
expect((await create('team')).status).toBe(200)
expect(vmEnv(h)).toEqual(TEAM_AND_REPO)
for (const value of PERSONAL_VALUES) {
expect(everythingSent(h)).not.toContain(value)
}
})
it('drops them from a running workspace the moment it is shared, and brings them back when it is private again', async () => {
const { h, create, share, mia } = await seeded()
const id: string = (await create()).body.sandbox.id
expect(vmEnv(h).DB_PASSWORD).toBe('personal-db-password')
const before = h.vercel.commands.length
expect((await share(id, 'team')).status).toBe(200)
expect(vmEnv(h, ENV_COMMAND)).toEqual(TEAM_AND_REPO)
for (const value of PERSONAL_VALUES) {
expect(everythingSent(h, before)).not.toContain(value)
}
// A wake while shared resolves the same way.
await h.call('POST', `/v1/sandboxes/${id}/suspend`, { bearer: mia })
await h.call('POST', `/v1/sandboxes/${id}/resume`, { bearer: mia })
expect(vmEnv(h)).toEqual(TEAM_AND_REPO)
expect((await share(id, 'private')).status).toBe(200)
expect(vmEnv(h, ENV_COMMAND)).toMatchObject({ DB_PASSWORD: 'personal-db-password', FOO: 'personal-foo-value' })
})
it('does not pick up a personal secret the owner saves while the workspace is shared', async () => {
const { h, create, put, mia } = await seeded()
await create('team')
await put('personal', 'LATER', 'personal-db-password', mia)
const refreshes = h.vercel.commands.filter((c) => c.command === ENV_COMMAND)
for (const refresh of refreshes) {
expect(decodeEnv(refresh.env.ORCA_SECRET_ENV)).toEqual(TEAM_AND_REPO)
}
})
})
describe('personal model keys in shared workspaces with egress placeholders (SEC-5)', () => {
async function placeholderSetup() {
const { privateKey, publicKey } = await generateKeyPair('RS256')
const jwks = { keys: [{ ...(await exportJWK(publicKey)), kid: 'v1', alg: 'RS256' }] }
const upstream: { url: string; headers: Headers }[] = []
const ctx = await seeded(
{ SECRETS_EGRESS_PLACEHOLDERS: 'on', EGRESS_PROXY_URL: PROXY_URL },
{
egressKeysForIssuer: () => createLocalJWKSet(jwks),
credentials: { authorizationFor: async () => 'Bearer ghs_fake' },
egressFetch: async (input, init) => {
upstream.push({ url: String(input), headers: new Headers(init?.headers) })
return new Response('ok', { status: 200 })
}
}
)
async function proxied(sandboxId: string, host: string, headers: Record<string, string>) {
const token = await new SignJWT({ team_id: 'team_orca', project_id: 'prj_orca', sandbox_name: `orca-test-${sandboxId}` })
.setProtectedHeader({ alg: 'RS256', kid: 'v1' })
.setIssuer('https://oidc.vercel.com/team_orca')
.setAudience(PROXY_URL)
.setIssuedAt()
.setExpirationTime('5m')
.sign(privateKey)
const response = await ctx.h.send(
new Request(`${PROXY_URL}/v1/messages`, {
method: 'POST',
body: '{"model":"x"}',
headers: {
'vercel-forwarded-host': host,
'vercel-forwarded-scheme': 'https',
'vercel-forwarded-port': '443',
'vercel-forwarded-path': '/v1/messages',
'vercel-sandbox-oidc-token': token,
...headers
}
})
)
return response.status
}
return { ...ctx, proxied, upstream }
}
it('gives a shared workspace no placeholder and no route for the owner’s personal key; the team key still works', async () => {
const { h, create, proxied, upstream } = await placeholderSetup()
const id: string = (await create('team')).body.sandbox.id
const env = vmEnv(h)
expect(env.ANTHROPIC_API_KEY).toBe(`orca-ph-anthropic-api-key-${id}`)
expect(env).not.toHaveProperty('OPENAI_API_KEY')
expect(env).not.toHaveProperty('DB_PASSWORD')
const [box] = [...h.vercel.boxes.values()]
// No forward rule for the personal key: the host is plain allowlisted, nothing is swapped there.
expect(box!.policy.allow['api.openai.com']).toEqual([])
expect(await proxied(id, 'api.openai.com', { authorization: `Bearer orca-ph-openai-api-key-${id}` })).toBe(403)
expect(await proxied(id, 'api.anthropic.com', { 'x-api-key': `orca-ph-anthropic-api-key-${id}` })).toBe(200)
expect(upstream).toHaveLength(1)
expect(upstream[0]!.headers.get('x-api-key')).toBe(TEAM_KEY)
})
it('stops swapping the owner’s personal key at the proxy as soon as a running workspace is shared', async () => {
const { h, create, share, proxied, upstream } = await placeholderSetup()
const id: string = (await create()).body.sandbox.id
const placeholder = `orca-ph-openai-api-key-${id}`
expect(vmEnv(h).OPENAI_API_KEY).toBe(placeholder)
expect(await proxied(id, 'api.openai.com', { authorization: `Bearer ${placeholder}` })).toBe(200)
expect(upstream.at(-1)!.headers.get('authorization')).toBe(`Bearer ${PERSONAL_OPENAI}`)
expect((await share(id, 'team')).status).toBe(200)
expect(vmEnv(h, ENV_COMMAND)).not.toHaveProperty('OPENAI_API_KEY')
// A process still holding the old placeholder gets nothing for it.
expect(await proxied(id, 'api.openai.com', { authorization: `Bearer ${placeholder}` })).toBe(403)
expect(upstream).toHaveLength(1)
})
})
-21
View File
@@ -1,21 +0,0 @@
// "Copy link" on billing buttons: the Stripe Checkout or Customer Portal URL the button would open,
// minted the same way (same account, same order, same setup-session fallback) but returned instead.
import type { OrcaBillingCheckoutArgs, OrcaBillingLinkResult } from '../../shared/orca-billing'
import { createCheckoutUrl, createPortalUrl } from './billing-client'
import { mintHosted } from './billing-service'
import { withSetupSessionFallback } from './billing-setup-session-fallback'
export function getOrcaBillingCheckoutLink(
userDataPath: string,
args: OrcaBillingCheckoutArgs
): Promise<OrcaBillingLinkResult> {
return withSetupSessionFallback(args, (checkoutArgs) =>
mintHosted(userDataPath, (token, endpoints) =>
createCheckoutUrl(endpoints, token, checkoutArgs)
)
)
}
export function getOrcaBillingPortalLink(userDataPath: string): Promise<OrcaBillingLinkResult> {
return mintHosted(userDataPath, (token, endpoints) => createPortalUrl(endpoints, token))
}
+1 -1
View File
@@ -222,7 +222,7 @@ export async function getOrcaBillingTeamPlans(
type CreateHostedUrl = (token: string, endpoints: BillingEndpoints) => Promise<string>
/** Mints a Stripe-hosted Checkout/Portal URL for the active account without opening it. */
export async function mintHosted(
async function mintHosted(
userDataPath: string,
createUrl: CreateHostedUrl
): Promise<OrcaBillingLinkResult> {
@@ -73,11 +73,6 @@ export async function createCloudWorkspaceFromGitHub(
onProgress: (progress) => io.onLog?.(hostedProgressLine(progress))
}
)
if (io.signal?.aborted) {
// Cancelled just as it answered: nothing will open it, so it must not keep running (and billing).
await client.destroy(ready.sandbox.id).catch(() => undefined)
return { ok: false, code: 'failed', message: 'Cancelled.' }
}
return { ok: true, value: { sandboxId: ready.sandbox.id } }
} catch (error) {
const result = hostedCreateFailure(error)
@@ -23,7 +23,6 @@ const SETUP_SESSION_ID = /^cs_[A-Za-z0-9_-]{22}$/
export const HOSTED_ACCOUNT_CHANNELS = [
CH.getConfig,
CH.connectGitHub,
CH.gitHubInstallLink,
CH.getRepoAccess,
CH.listGitHubRepositories,
CH.createFromGitHub,
@@ -107,15 +106,6 @@ export function registerHostedAccountHandlers(
}
})
// "Copy link": the same install page, minted the same way, for another browser or profile.
ipcMain.handle(CH.gitHubInstallLink, async (_event, args?: RepoArgs) => {
try {
return { ok: true, value: await mintInstallUrl(args) }
} catch (error) {
return failure(error)
}
})
ipcMain.handle(CH.getRepoAccess, async (_event, args?: RepoArgs) => {
const target = repoTarget(args)
if (!target) {
@@ -1,5 +1,6 @@
// "Copy link" twins of Connect GitHub (App install) and Connect your GitHub (OAuth): the same page,
// minted the same way, returned instead of opened, and still only ever a github.com page.
// "Copy link" for Connect your GitHub (OAuth sign-in): the same page, minted the same way, returned
// instead of opened, and still only ever a github.com page. The App install has no link channel:
// Copy link is for sign-in pages only.
import { afterEach, expect, it, vi } from 'vitest'
const handlers = new Map<string, (...args: unknown[]) => unknown>()
@@ -56,25 +57,24 @@ function register(url: string) {
return { connectGitHub, connectGitHubUser }
}
it('registers the link channels with the window allowlist', () => {
expect(HOSTED_ACCOUNT_CHANNELS).toEqual(
expect.arrayContaining([CH.gitHubInstallLink, CH.gitHubUserConnectLink])
)
it('registers the OAuth link channel, and no App-install link channel', () => {
expect(HOSTED_ACCOUNT_CHANNELS).toContain(CH.gitHubUserConnectLink)
expect(HOSTED_ACCOUNT_CHANNELS).not.toContain('orcaCloudWorkspace:gitHubInstallLink')
})
it('returns the install page minted like Connect GitHub, without opening it', async () => {
it('Connect GitHub still opens the install page minted for the repository', async () => {
const url = 'https://github.com/apps/x/installations/new?state=s'
const { connectGitHub } = register(url)
expect(
await handlers.get(CH.gitHubInstallLink)?.({}, { repoUrl: REPO, setupSessionId: SESSION })
).toEqual({ ok: true, value: url })
await handlers.get(CH.connectGitHub)?.({}, { repoUrl: REPO, setupSessionId: SESSION })
).toEqual({ ok: true, value: null })
expect(connectGitHub).toHaveBeenLastCalledWith(undefined, {
repo: REPO,
setupSessionId: SESSION,
repoId: 7,
ownerId: 50
})
expect(openExternal).not.toHaveBeenCalled()
expect(openExternal).toHaveBeenCalledWith(url)
})
it('returns the OAuth page minted like Connect your GitHub, without opening it', async () => {
@@ -84,7 +84,7 @@ it('returns the OAuth page minted like Connect your GitHub, without opening it',
expect(openExternal).not.toHaveBeenCalled()
})
it('never hands out a page that is not on github.com', async () => {
it('never opens or hands out a page that is not on github.com', async () => {
for (const url of [
'https://github.com.evil.example/install',
'http://github.com/login/oauth/authorize',
@@ -92,7 +92,7 @@ it('never hands out a page that is not on github.com', async () => {
]) {
handlers.clear()
register(url)
expect(await handlers.get(CH.gitHubInstallLink)?.({}, {})).toMatchObject({
expect(await handlers.get(CH.connectGitHub)?.({}, {})).toMatchObject({
ok: false,
code: 'failed'
})
@@ -101,4 +101,5 @@ it('never hands out a page that is not on github.com', async () => {
code: 'failed'
})
}
expect(openExternal).not.toHaveBeenCalled()
})
@@ -12,7 +12,7 @@ import {
unlinkOrcaProfileFromCloud
} from '../orca-profiles/cloud-auth/profile-cloud-index'
import { ensureActiveOrcaProfile } from '../orca-profiles/profile-index-store'
import { getHostedSandboxConfig } from './hosted-sandbox-config'
import { getHostedSandboxConfig, isMfaRequiredRefusal } from './hosted-sandbox-config'
const state = { dir: '' }
installFakeAppEnvironment({ getPath: () => state.dir })
@@ -118,3 +118,21 @@ describe('getHostedSandboxConfig sandbox tokens', () => {
expect(claims(await b.getAccessToken()).sub).toBe('user-b')
})
})
describe('isMfaRequiredRefusal', () => {
it('recognizes the team MFA refusal and leaves the body readable', async () => {
const response = Response.json(
{ error: 'mfa_required', orgId: 'org_1', enforceAt: 5 },
{ status: 403 }
)
expect(await isMfaRequiredRefusal(response)).toBe(true)
expect(await response.json()).toMatchObject({ orgId: 'org_1' })
})
it('is false for other refusals and for bodies that are not JSON', async () => {
for (const body of [{ error: 'not_a_member' }, { error: 'sandbox_not_entitled' }, {}, null]) {
expect(await isMfaRequiredRefusal(Response.json(body, { status: 403 }))).toBe(false)
}
expect(await isMfaRequiredRefusal(new Response('<html>', { status: 403 }))).toBe(false)
})
})
@@ -30,6 +30,24 @@ export type HostedSandboxConfig = {
fetch?: typeof fetch
}
/** `reason` on the provider error when the team's MFA policy refused the token. */
export const MFA_REQUIRED_REASON = 'mfa_required'
/** Reads a copy of the body, so the caller can still read the response. */
export async function isMfaRequiredRefusal(response: Response): Promise<boolean> {
try {
const body: unknown = await response.clone().json()
return (
typeof body === 'object' &&
body !== null &&
'error' in body &&
body.error === MFA_REQUIRED_REASON
)
} catch {
return false
}
}
const SandboxTokenBody = z.object({
sandboxToken: z.string().min(1).max(8192),
expiresAt: z.number().int().positive()
@@ -232,6 +250,15 @@ async function mintSandboxToken(
if (response.status === 403 && requestedOrg && (await isNotAMember(response))) {
throw orgSwitchError(active)
}
if (response.status === 403 && (await isMfaRequiredRefusal(response))) {
// The team requires MFA and this person has none past the deadline. Signing in again
// would not help, so this is not a session error: the reason lets the UI show setup.
throw new EnvironmentProviderError(
'unauthorized',
'Your team requires two-factor authentication. Set it up to use its cloud workspaces.',
MFA_REQUIRED_REASON
)
}
if (response.status === 401 || response.status === 403) {
throw new OrcaCloudRequestError(response.status)
}
@@ -0,0 +1,105 @@
// GH-CREATE-CANCEL: a create cancelled in flight never leaves a sandbox running, for the owned
// create and the GitHub-only create alike (both use createSandboxWithProgress).
import { describe, expect, it, vi } from 'vitest'
import { EnvironmentProviderError } from '../environment-providers/environment-provider-driver'
import { HostedEntitlementDeniedError } from './hosted-environment-provider'
import { reclaimCancelledCreate } from './hosted-sandbox-create-reclaim'
import { createSandboxWithProgress } from './hosted-sandbox-driver'
const READY = {
sandbox: {
id: 'sbx_1',
workspaceId: 'web-1',
status: 'running' as const,
machineSize: 'standard' as const,
region: 'iad1',
session: null,
createdAt: 1
},
connection: { type: 'orca-server' as const, pairingCode: 'code', projectRoot: '/work' }
}
const BODY = { workspaceId: 'web-1', machineSize: 'standard' as const }
const quiet = { waitMs: 0, log: () => {} }
function client() {
return {
create: vi.fn(async () => READY),
bootPlan: vi.fn(async () => 'clone' as const),
cloneStatus: vi.fn(async () => ({ state: 'done' as const })),
destroy: vi.fn(async (id: string) => ({ id, status: 'destroyed' as const }))
}
}
describe('reclaimCancelledCreate', () => {
it('replays the create by its key and deletes the sandbox it gets back', async () => {
const api = client()
expect(await reclaimCancelledCreate(api, BODY, 'create:k1', quiet)).toBe(true)
expect(api.create).toHaveBeenCalledWith(BODY, undefined, 'create:k1')
expect(api.destroy).toHaveBeenCalledWith('sbx_1')
})
it('waits while the first create is still in progress (409), then deletes', async () => {
const api = client()
api.create
.mockRejectedValueOnce(new EnvironmentProviderError('conflict', 'idempotency_in_progress'))
.mockRejectedValueOnce(new EnvironmentProviderError('unavailable', 'try later'))
expect(await reclaimCancelledCreate(api, BODY, 'create:k1', quiet)).toBe(true)
expect(api.create).toHaveBeenCalledTimes(3)
expect(api.destroy).toHaveBeenCalledWith('sbx_1')
})
it('a refused replay means the cancelled create made nothing either', async () => {
const api = client()
api.create.mockRejectedValueOnce(new HostedEntitlementDeniedError('denied', 'no_subscription'))
expect(await reclaimCancelledCreate(api, BODY, 'create:k1', quiet)).toBe(true)
expect(api.destroy).not.toHaveBeenCalled()
})
it('gives up (false) when it can never tell', async () => {
const api = client()
api.create.mockRejectedValue(new EnvironmentProviderError('unavailable', 'down'))
expect(await reclaimCancelledCreate(api, BODY, 'create:k1', { ...quiet, attempts: 3 })).toBe(
false
)
})
})
describe('createSandboxWithProgress cancel', () => {
const spec = { workspaceId: 'web-1', machineSize: 'standard', idempotencyKey: 'create:k1' }
it('cancelled while the create was in flight: reclaims by key, then reports the cancel', async () => {
const api = client()
const controller = new AbortController()
api.create.mockImplementationOnce(async () => {
controller.abort()
throw new EnvironmentProviderError('aborted', 'Cancelled.')
})
await expect(
createSandboxWithProgress(api, spec, { signal: controller.signal })
).rejects.toMatchObject({ code: 'aborted' })
// The replay (no signal, same key) found the sandbox and deleted it.
expect(api.create).toHaveBeenLastCalledWith(expect.anything(), undefined, 'create:k1')
expect(api.destroy).toHaveBeenCalledWith('sbx_1')
})
it('cancelled just as the create answered: deletes the sandbox and reports the cancel', async () => {
const api = client()
const controller = new AbortController()
api.create.mockImplementationOnce(async () => {
controller.abort()
return READY
})
await expect(
createSandboxWithProgress(api, spec, { signal: controller.signal })
).rejects.toMatchObject({ code: 'aborted' })
expect(api.destroy).toHaveBeenCalledWith('sbx_1')
expect(api.create).toHaveBeenCalledTimes(1)
})
it('not cancelled: no replay, no delete', async () => {
const api = client()
await expect(createSandboxWithProgress(api, spec, {})).resolves.toBe(READY)
expect(api.create).toHaveBeenCalledTimes(1)
expect(api.destroy).not.toHaveBeenCalled()
})
})
@@ -0,0 +1,64 @@
// A create cancelled while its request was in flight may still have made a sandbox on the control
// plane, and a sandbox bills (GH-CREATE-CANCEL). The control plane keys creates by Idempotency-Key
// and body: sending the same create again hands back the sandbox the first one made (or makes one, if
// the first never arrived), and that sandbox is deleted. Shared by the owned create (the recipe) and
// the GitHub-only create, which both go through createSandboxWithProgress.
import { isEnvironmentProviderError } from '../environment-providers/environment-provider-driver'
import type { HostedSandboxControlPlaneClient } from './hosted-sandbox-control-plane-client'
type CreateBody = Parameters<HostedSandboxControlPlaneClient['create']>[0]
const RECLAIM_ATTEMPTS = 8
const RECLAIM_WAIT_MS = 5_000
/** The first create may still be running (409 in progress) or the service briefly unreachable. */
function worthRetrying(error: unknown): boolean {
return (
isEnvironmentProviderError(error, 'conflict') ||
isEnvironmentProviderError(error, 'unavailable') ||
isEnvironmentProviderError(error, 'timeout') ||
!isEnvironmentProviderError(error)
)
}
/**
* Deletes whatever the cancelled create made. True once it is gone (or the control plane refused
* the create, so nothing was made); false when it still couldn't tell after every attempt.
*/
export async function reclaimCancelledCreate(
client: Pick<HostedSandboxControlPlaneClient, 'create' | 'destroy'>,
body: CreateBody,
idempotencyKey: string,
{
attempts = RECLAIM_ATTEMPTS,
waitMs = RECLAIM_WAIT_MS,
log = (message: string) => console.warn(message)
}: { attempts?: number; waitMs?: number; log?: (message: string) => void } = {}
): Promise<boolean> {
for (let attempt = 1; attempt <= attempts; attempt += 1) {
let sandboxId: string
try {
// No signal: this request is the cleanup and must not be cancelled with the create.
sandboxId = (await client.create(body, undefined, idempotencyKey)).sandbox.id
} catch (error) {
if (!worthRetrying(error)) {
// Refused (billing, sign-in, bad request): the cancelled create made nothing either.
return true
}
log(
`[orca-cloud] cancelled create: replay ${attempt}/${attempts} failed (${isEnvironmentProviderError(error) ? error.code : 'error'})`
)
await new Promise((resolve) => setTimeout(resolve, waitMs))
continue
}
try {
await client.destroy(sandboxId)
log(`[orca-cloud] cancelled create: deleted sandbox ${sandboxId}`)
return true
} catch {
await new Promise((resolve) => setTimeout(resolve, waitMs))
}
}
log('[orca-cloud] cancelled create: could not confirm the sandbox was deleted')
return false
}
@@ -25,6 +25,7 @@ import type {
} from './hosted-environment-provider'
import type { HostedSandboxControlPlaneClient } from './hosted-sandbox-control-plane-client'
import { takeSuspendReason } from './idle-sleep-requests'
import { reclaimCancelledCreate } from './hosted-sandbox-create-reclaim'
export const HOSTED_SANDBOX_DRIVER_ID = 'orca-cloud'
@@ -144,21 +145,34 @@ export async function createSandboxWithProgress(
)
.catch(() => undefined)
}
const ready = await client.create(
{
workspaceId: spec.workspaceId,
machineSize,
// Named rows: Home shows the workspace's name, never an untitled sandbox (PC-8).
...(spec.workspaceName?.trim() ? { title: spec.workspaceName.trim().slice(0, 120) } : {}),
...(spec.region ? { region: spec.region } : {}),
...(spec.repo ? { repo: spec.repo } : {})
},
ctx?.signal,
spec.idempotencyKey
)
const body = {
workspaceId: spec.workspaceId,
machineSize,
// Named rows: Home shows the workspace's name, never an untitled sandbox (PC-8).
...(spec.workspaceName?.trim() ? { title: spec.workspaceName.trim().slice(0, 120) } : {}),
...(spec.region ? { region: spec.region } : {}),
...(spec.repo ? { repo: spec.repo } : {})
}
let ready: HostedSandboxReadyResponse
try {
ready = await client.create(body, ctx?.signal, spec.idempotencyKey)
} catch (error) {
// GH-CREATE-CANCEL: cancelled in flight, the control plane may still have made it: find it by
// its key and delete it before reporting the cancel.
if (ctx?.signal?.aborted && spec.idempotencyKey) {
await reclaimCancelledCreate(client, body, spec.idempotencyKey)
}
throw error
}
if (ready.clone) {
// A cancelled, failed or stalled clone deletes the sandbox itself.
await waitForClone(client, ready.sandbox.id, ctx, { mode: ready.clone.mode ?? 'clone' })
}
if (ctx?.signal?.aborted) {
// Cancelled just as it answered: nothing will use it, so it must not keep running (and billing).
await client.destroy(ready.sandbox.id).catch(() => undefined)
throw new EnvironmentProviderError('aborted', 'Cancelled.')
}
ctx?.onProgress?.({ phase: 'connecting' })
return ready
}
@@ -0,0 +1,95 @@
import { afterEach, beforeEach, expect, it, vi } from 'vitest'
// The only channel registered here returns a summary.
const handlers = new Map<string, (_event: unknown, args?: unknown) => RecipeForwardedEnvSummary>()
const { listRuntimesMock, recipeContextMock } = vi.hoisted(() => ({
listRuntimesMock: vi.fn(),
recipeContextMock: vi.fn()
}))
vi.mock('electron', () => ({
app: { getPath: () => '/tmp/orca-user-data' },
ipcMain: {
handle: (channel: string, handler: never) => handlers.set(channel, handler),
removeHandler: vi.fn()
}
}))
vi.mock('../../shared/ephemeral-vm-runtime-store', () => ({
listEphemeralVmRuntimes: listRuntimesMock
}))
vi.mock('./ephemeral-vm-recipe-context', () => ({
getRuntimeRecipeContext: recipeContextMock
}))
import { registerRecipeForwardedEnvHandler } from './ephemeral-vm-forwarded-env'
import type { RecipeForwardedEnvSummary } from '../../shared/ephemeral-vm-recipe-forwarded-env'
// oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the handler hands the store to the mocked recipe context only
const store = {} as never
function summarize(args?: unknown): RecipeForwardedEnvSummary {
const handler = handlers.get('ephemeralVm:forwardedEnvSummary')
if (!handler) {
throw new Error('handler not registered')
}
return handler({}, args)
}
beforeEach(() => {
vi.stubEnv('AWS_SECRET_ACCESS_KEY', 'aws-secret')
vi.stubEnv('OPENAI_API_KEY', 'sk-openai')
listRuntimesMock.mockReturnValue([
{ id: 'runtime-1', recipeId: 'aws', runtimeEnvironmentId: 'env-recipe' }
])
recipeContextMock.mockReturnValue({ recipe: { id: 'aws', passEnv: ['AWS_*'] } })
registerRecipeForwardedEnvHandler(store)
})
afterEach(() => {
vi.unstubAllEnvs()
vi.clearAllMocks()
handlers.clear()
})
it("applies the recipe's own passEnv, looked up from the host's runtime", () => {
const summary = summarize({ environmentId: 'env-recipe' })
expect(recipeContextMock).toHaveBeenCalledWith(store, '/tmp/orca-user-data', 'runtime-1')
expect(summary.narrowed).toBe(true)
expect(summary.keyLike).toContain('AWS_SECRET_ACCESS_KEY')
expect(summary.keyLike).not.toContain('OPENAI_API_KEY')
})
it('ignores a passEnv sent from the renderer', () => {
const summary = summarize({ environmentId: 'env-recipe', passEnv: ['OPENAI_*'] })
expect(summary.keyLike).toContain('AWS_SECRET_ACCESS_KEY')
expect(summary.keyLike).not.toContain('OPENAI_API_KEY')
const withoutHost = summarize({ passEnv: ['AWS_*'] })
expect(withoutHost.narrowed).toBe(false)
expect(withoutHost.keyLike).toContain('OPENAI_API_KEY')
})
it('falls back to the whole env for an unknown host or an unresolvable recipe', () => {
const unknown = summarize({ environmentId: 'env-missing' })
expect(recipeContextMock).not.toHaveBeenCalled()
expect(unknown.narrowed).toBe(false)
expect(unknown.keyLike).toEqual(
expect.arrayContaining(['AWS_SECRET_ACCESS_KEY', 'OPENAI_API_KEY'])
)
recipeContextMock.mockImplementation(() => {
throw new Error('recipe not found')
})
const unresolved = summarize({ environmentId: 'env-recipe' })
expect(unresolved.narrowed).toBe(false)
expect(unresolved.keyLike).toContain('OPENAI_API_KEY')
})
it('summarizes the whole env when the recipe sets no passEnv', () => {
recipeContextMock.mockReturnValue({ recipe: { id: 'aws' } })
const summary = summarize({ environmentId: 'env-recipe' })
expect(summary.narrowed).toBe(false)
expect(summary.keyLike).toEqual(
expect.arrayContaining(['AWS_SECRET_ACCESS_KEY', 'OPENAI_API_KEY'])
)
})
+37 -4
View File
@@ -1,13 +1,46 @@
import { ipcMain } from 'electron'
import { app, ipcMain } from 'electron'
import type { Store } from '../persistence/loading-store/store'
import { listEphemeralVmRuntimes } from '../../shared/ephemeral-vm-runtime-store'
import {
summarizeRecipeForwardedEnv,
type RecipeForwardedEnvSummary
} from '../../shared/ephemeral-vm-recipe-forwarded-env'
import { getRuntimeRecipeContext } from './ephemeral-vm-recipe-context'
/** Which recipe host the renderer asks about. Main looks its recipe up; it never takes a passEnv. */
export type RecipeForwardedEnvSummaryArgs = { environmentId?: string }
/** The recipe's passEnv as its lifecycle scripts get it; undefined (whole env) when unresolvable. */
export function resolveRecipeHostPassEnv(
store: Store,
userDataPath: string,
environmentId: unknown
): readonly string[] | undefined {
if (typeof environmentId !== 'string' || environmentId.length === 0) {
return undefined
}
try {
const runtime = listEphemeralVmRuntimes(userDataPath).find(
(entry) => entry.runtimeEnvironmentId === environmentId
)
return runtime
? getRuntimeRecipeContext(store, userDataPath, runtime.id).recipe.passEnv
: undefined
} catch {
// Why: an unresolvable recipe falls back to the whole env, which can only over-warn.
return undefined
}
}
/** Recipe scripts inherit this process's env (buildRecipeEnv); only the names cross to the renderer. */
export function registerRecipeForwardedEnvHandler(): void {
export function registerRecipeForwardedEnvHandler(store: Store): void {
ipcMain.removeHandler('ephemeralVm:forwardedEnvSummary')
ipcMain.handle('ephemeralVm:forwardedEnvSummary', (): RecipeForwardedEnvSummary =>
summarizeRecipeForwardedEnv(process.env)
ipcMain.handle(
'ephemeralVm:forwardedEnvSummary',
(_event, args?: RecipeForwardedEnvSummaryArgs): RecipeForwardedEnvSummary =>
summarizeRecipeForwardedEnv(
process.env,
resolveRecipeHostPassEnv(store, app.getPath('userData'), args?.environmentId)
)
)
}
+1 -1
View File
@@ -103,7 +103,7 @@ export function registerEphemeralVmHandlers(store: Store, pluginService?: Plugin
return listPickerRecipes(store, args.repoId, pluginService)
})
registerRecipeForwardedEnvHandler()
registerRecipeForwardedEnvHandler(store)
ipcMain.handle(
'ephemeralVm:listRecipeCatalog',
@@ -2,7 +2,6 @@ import { ipcMain } from 'electron'
import { z } from 'zod'
import type {
OrcaBillingCheckoutArgs,
OrcaBillingLinkResult,
OrcaBillingOpenResult,
OrcaBillingOverageArgs,
OrcaBillingOverageResult,
@@ -27,10 +26,6 @@ import {
openOrcaBillingPortal,
setOrcaBillingOverage
} from '../../billing/billing-service'
import {
getOrcaBillingCheckoutLink,
getOrcaBillingPortalLink
} from '../../billing/billing-hosted-links'
import { getProfileUserDataPath } from '../../orca-profiles/profile-storage-paths'
import { ensureActiveOrcaProfile } from '../../orca-profiles/profile-index-store'
import { notifyUsageAlertIfDue } from '../../billing/usage-alert-notifier'
@@ -223,13 +218,4 @@ export function registerOrcaProfileBillingHandlers(store: Store): void {
ipcMain.handle('orcaProfiles:billingOpenPortal', async (): Promise<OrcaBillingOpenResult> =>
openOrcaBillingPortal(getProfileUserDataPath())
)
// "Copy link": the same Stripe URLs, minted but not opened (paste into another browser profile).
ipcMain.handle('orcaProfiles:billingPortalLink', async (): Promise<OrcaBillingLinkResult> =>
getOrcaBillingPortalLink(getProfileUserDataPath())
)
ipcMain.handle(
'orcaProfiles:billingCheckoutLink',
async (_event, rawArgs: unknown): Promise<OrcaBillingLinkResult> =>
getOrcaBillingCheckoutLink(getProfileUserDataPath(), billingCheckoutArgsFromUnknown(rawArgs))
)
}
@@ -11,6 +11,22 @@ import type {
OrcaProfileOrgMembersListArgs,
OrcaProfileOrgMembersListResult
} from '../../../shared/orca-profiles'
import type { OrcaAccountMfaResult } from '../../../shared/orca-account-mfa'
import { getOrcaProfileAccountMfa } from '../../orca-profiles/cloud-mfa/profile-cloud-mfa-service'
import {
ORCA_TEAM_MFA_GRACE_CHOICES,
type OrcaTeamMfaGrace,
type OrcaTeamMfaPendingResult,
type OrcaTeamMfaPolicyResult,
type OrcaTeamMfaPolicySetResult,
type OrcaTeamMfaRemindResult
} from '../../../shared/orca-team-mfa-policy'
import {
getOrcaTeamMfaPolicy,
listOrcaTeamMfaPending,
remindOrcaTeamMfa,
setOrcaTeamMfaPolicy
} from '../../orca-profiles/cloud-mfa/profile-cloud-team-mfa-service'
import { getProfileUserDataPath } from '../../orca-profiles/profile-storage-paths'
import {
changeOrcaProfileOrgMemberRole,
@@ -144,6 +160,48 @@ export function registerOrcaProfileOrgMemberHandlers(): void {
createOrcaProfileOrg(getProfileUserDataPath(), { name: orgCreateNameFromUnknown(rawArgs) })
)
ipcMain.handle('orcaProfiles:accountMfa', async (): Promise<OrcaAccountMfaResult> =>
getOrcaProfileAccountMfa(getProfileUserDataPath())
)
ipcMain.handle(
'orcaProfiles:teamMfaPolicy',
async (_event, rawArgs: unknown): Promise<OrcaTeamMfaPolicyResult> =>
getOrcaTeamMfaPolicy(getProfileUserDataPath(), orgMembersScopedArgs(rawArgs).orgId)
)
ipcMain.handle(
'orcaProfiles:teamMfaPolicySet',
async (_event, rawArgs: unknown): Promise<OrcaTeamMfaPolicySetResult> => {
const { orgId, record } = orgMembersScopedArgs(rawArgs)
// Only the fixed choices cross to the server; anything else is refused here.
const enforce: OrcaTeamMfaGrace | 'off' | undefined =
record.enforce === 'off'
? 'off'
: ORCA_TEAM_MFA_GRACE_CHOICES.find((choice) => choice === record.enforce)
if (enforce === undefined) {
return { status: 'failed', error: 'invalid_enforce' }
}
return setOrcaTeamMfaPolicy(getProfileUserDataPath(), { orgId, enforce })
}
)
ipcMain.handle(
'orcaProfiles:teamMfaPending',
async (_event, rawArgs: unknown): Promise<OrcaTeamMfaPendingResult> =>
listOrcaTeamMfaPending(getProfileUserDataPath(), orgMembersScopedArgs(rawArgs).orgId)
)
ipcMain.handle(
'orcaProfiles:teamMfaRemind',
async (_event, rawArgs: unknown): Promise<OrcaTeamMfaRemindResult> => {
const { orgId, record } = orgMembersScopedArgs(rawArgs)
const userId =
typeof record.userId === 'string' && record.userId.length <= 128 ? record.userId : undefined
return remindOrcaTeamMfa(getProfileUserDataPath(), { orgId, ...(userId ? { userId } : {}) })
}
)
ipcMain.handle(
'orcaProfiles:orgMembersList',
async (
@@ -0,0 +1,27 @@
import { describe, expect, it } from 'vitest'
import { normalizeAccountMfa } from './profile-cloud-mfa-service'
const API = 'https://cloud.orca.dev'
describe('normalizeAccountMfa', () => {
it('keeps the status and a setup link on Orca Cloud', () => {
expect(
normalizeAccountMfa({ mfa: 'off', setupUrl: `${API}/v1/account/security` }, API)
).toEqual({ mfa: 'off', setupUrl: `${API}/v1/account/security` })
expect(normalizeAccountMfa({ mfa: 'on', setupUrl: `${API}/x` }, `${API}/`).mfa).toBe('on')
})
it.each([
['another site', { mfa: 'off', setupUrl: 'https://evil.example/v1/account/security' }],
['a look-alike host', { mfa: 'off', setupUrl: 'https://cloud.orca.dev.evil.example/' }],
['plain http', { mfa: 'off', setupUrl: 'http://cloud.orca.dev/v1/account/security' }],
['credentials in the link', { mfa: 'off', setupUrl: 'https://user:pw@cloud.orca.dev/' }],
['a script link', { mfa: 'off', setupUrl: 'javascript:alert(1)' }],
['no link', { mfa: 'off' }],
['an unknown status', { mfa: 'pending', setupUrl: `${API}/v1/account/security` }],
['a boolean status', { mfa: true, setupUrl: `${API}/v1/account/security` }],
['nothing', null]
])('refuses %s', (_name, body) => {
expect(() => normalizeAccountMfa(body, API)).toThrow('invalid_orca_account_mfa')
})
})
@@ -0,0 +1,82 @@
import type { OrcaAccountMfa, OrcaAccountMfaResult } from '../../../shared/orca-account-mfa'
import type { OrcaCloudAuthConfig } from '../cloud-auth/profile-cloud-auth-config'
import {
getOrcaCloudAuthConfig,
isOrcaCloudDevAuthEnabled
} from '../cloud-auth/profile-cloud-auth-config'
import { OrcaCloudRequestError } from '../cloud-auth/profile-cloud-client'
import type { OrcaCloudSession } from '../cloud-session/profile-cloud-session-store'
import { extractErrorCode, requestInit } from '../cloud-org/profile-cloud-org-members-client'
import { runOrgMemberCall } from '../cloud-org/profile-cloud-org-members-service'
import { ensureActiveOrcaProfile } from '../profile-index-store'
/**
* The renderer opens `setupUrl` in the browser, so it must be a page on Orca Cloud's own origin:
* a compromised or misconfigured answer cannot send the person to another site to "set up MFA".
*/
export function normalizeAccountMfa(value: unknown, apiBaseUrl: string): OrcaAccountMfa {
const record: Record<string, unknown> =
typeof value === 'object' && value !== null ? { ...value } : {}
const mfa = record.mfa === 'on' || record.mfa === 'off' ? record.mfa : null
let setupUrl: URL | null = null
try {
setupUrl = typeof record.setupUrl === 'string' ? new URL(record.setupUrl) : null
} catch {
setupUrl = null
}
if (
!mfa ||
!setupUrl ||
setupUrl.origin !== new URL(apiBaseUrl).origin ||
setupUrl.username ||
setupUrl.password
) {
throw new Error('invalid_orca_account_mfa')
}
return { mfa, setupUrl: setupUrl.toString() }
}
async function fetchAccountMfa(
config: OrcaCloudAuthConfig,
session: OrcaCloudSession
): Promise<OrcaAccountMfa> {
const response = await fetch(
`${config.apiBaseUrl}/v1/desktop/auth/mfa`,
requestInit('GET', session.accessToken)
)
if (!response.ok) {
throw new OrcaCloudRequestError(response.status, await extractErrorCode(response))
}
const body: unknown = await response.json()
return normalizeAccountMfa(body, config.apiBaseUrl)
}
export async function getOrcaProfileAccountMfa(
userDataPath: string
): Promise<OrcaAccountMfaResult> {
const active = ensureActiveOrcaProfile(userDataPath)
// Local dev auth has no server and no factor to enrol.
if (isOrcaCloudDevAuthEnabled()) {
return { status: 'unsupported' }
}
const configState = getOrcaCloudAuthConfig()
if (!configState.configured) {
return { status: 'unconfigured' }
}
const result = await runOrgMemberCall(configState.config, active, userDataPath, (session) =>
fetchAccountMfa(configState.config, session)
)
switch (result.status) {
case 'ok':
return { status: 'ok', ...result.value }
case 'reconnect-required':
return { status: 'reconnect-required' }
case 'request-error':
// 404: an auth deployment from before this route, or a provider with no MFA status.
return result.error.statusCode === 404
? { status: 'unsupported' }
: { status: 'failed', error: result.error.message }
case 'failed':
return { status: 'failed', error: result.error }
}
}
@@ -0,0 +1,85 @@
import { describe, expect, it } from 'vitest'
import {
normalizePendingMembers,
normalizeTeamMfaPolicy,
sameOriginUrl
} from './profile-cloud-team-mfa-service'
const API = 'https://cloud.orca.dev'
const setupUrl = `${API}/v1/account/security`
describe('normalizeTeamMfaPolicy', () => {
it('reads a member answer: the deadline and their own state, no manager fields', () => {
expect(
normalizeTeamMfaPolicy(
{ policy: { enforceAt: 200, setAt: 100 }, self: { mfa: 'pending' }, setupUrl },
API
)
).toEqual({ policy: { enforceAt: 200, setAt: 100 }, self: 'pending', setupUrl })
})
it('reads a manager answer, including a policy the plan no longer covers', () => {
expect(
normalizeTeamMfaPolicy(
{
policy: null,
self: { mfa: 'on' },
setupUrl,
available: false,
pendingMembers: 3,
inactivePolicy: { enforceAt: 500 }
},
API
)
).toEqual({
policy: null,
self: 'on',
setupUrl,
manage: { available: false, pendingMembers: 3, inactiveEnforceAt: 500 }
})
})
it('never turns a malformed state into blocked', () => {
for (const self of [undefined, null, {}, { mfa: 'BLOCKED' }, { mfa: true }, 'blocked']) {
expect(normalizeTeamMfaPolicy({ policy: null, self, setupUrl }, API).self).toBe('unknown')
}
})
it('drops a half-formed deadline rather than guessing one', () => {
expect(
normalizeTeamMfaPolicy({ policy: { enforceAt: 'soon' }, self: { mfa: 'off' }, setupUrl }, API)
.policy
).toBeNull()
})
it('refuses an answer whose setup link is not on Orca Cloud', () => {
for (const link of ['https://evil.example/x', 'javascript:alert(1)', undefined, 7]) {
expect(() =>
normalizeTeamMfaPolicy({ policy: null, self: { mfa: 'off' }, setupUrl: link }, API)
).toThrow('invalid_orca_team_mfa_policy')
}
expect(sameOriginUrl('https://user:pw@cloud.orca.dev/x', API)).toBeNull()
expect(sameOriginUrl('http://cloud.orca.dev/x', API)).toBeNull()
})
})
describe('normalizePendingMembers', () => {
it('keeps members with an email and maps unknown states to off', () => {
expect(
normalizePendingMembers({
members: [
{ userId: 'u1', email: 'a@x.dev', displayName: 'Ada', mfa: 'pending' },
{ userId: null, email: 'b@x.dev', mfa: 'blocked' },
{ userId: 'u3', email: 'c@x.dev', mfa: 'whatever' },
{ userId: 'u4' },
'nope'
]
})
).toEqual([
{ userId: 'u1', email: 'a@x.dev', displayName: 'Ada', mfa: 'pending' },
{ userId: null, email: 'b@x.dev', mfa: 'blocked' },
{ userId: 'u3', email: 'c@x.dev', mfa: 'off' }
])
expect(normalizePendingMembers(null)).toEqual([])
})
})
@@ -0,0 +1,287 @@
import {
ORCA_TEAM_MFA_GRACE_CHOICES,
type OrcaTeamMfaGrace,
type OrcaTeamMfaPendingMember,
type OrcaTeamMfaPendingResult,
type OrcaTeamMfaPolicy,
type OrcaTeamMfaPolicyResult,
type OrcaTeamMfaPolicySetResult,
type OrcaTeamMfaRemindResult,
type OrcaTeamMfaSelfState
} from '../../../shared/orca-team-mfa-policy'
import {
getOrcaCloudAuthConfig,
isOrcaCloudDevAuthEnabled
} from '../cloud-auth/profile-cloud-auth-config'
import { OrcaCloudRequestError } from '../cloud-auth/profile-cloud-client'
import {
extractErrorCode,
orgMembersUrl,
requestInit
} from '../cloud-org/profile-cloud-org-members-client'
import {
runOrgMemberCall,
type OrgCallResult
} from '../cloud-org/profile-cloud-org-members-service'
import { ensureActiveOrcaProfile } from '../profile-index-store'
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null
}
const SELF_STATES: readonly OrcaTeamMfaSelfState[] = ['on', 'off', 'pending', 'blocked', 'unknown']
function finiteNumber(value: unknown): number | null {
return typeof value === 'number' && Number.isFinite(value) ? value : null
}
/** The setup link is opened in the browser, so only a page on Orca Cloud's own origin is kept. */
export function sameOriginUrl(value: unknown, apiBaseUrl: string): string | null {
if (typeof value !== 'string') {
return null
}
try {
const url = new URL(value)
return url.origin === new URL(apiBaseUrl).origin && !url.username && !url.password
? url.toString()
: null
} catch {
return null
}
}
function normalizeDeadline(value: unknown): { enforceAt: number; setAt: number } | null {
const record = isRecord(value) ? value : null
const enforceAt = finiteNumber(record?.enforceAt)
const setAt = finiteNumber(record?.setAt)
return enforceAt !== null && setAt !== null ? { enforceAt, setAt } : null
}
export function normalizeTeamMfaPolicy(value: unknown, apiBaseUrl: string): OrcaTeamMfaPolicy {
const record = isRecord(value) ? value : null
const setupUrl = sameOriginUrl(record?.setupUrl, apiBaseUrl)
if (!record || !setupUrl) {
throw new Error('invalid_orca_team_mfa_policy')
}
const selfRecord = isRecord(record.self) ? record.self : {}
// An unrecognized state is "unknown", never "blocked": only the server's word blocks anyone.
const self = SELF_STATES.find((state) => state === selfRecord.mfa) ?? 'unknown'
const pendingMembers = finiteNumber(record.pendingMembers)
const inactive = isRecord(record.inactivePolicy)
? finiteNumber(record.inactivePolicy.enforceAt)
: null
return {
policy: normalizeDeadline(record.policy),
self,
setupUrl,
// Present only when the server sent the manager fields; a member's answer has none.
...(typeof record.available === 'boolean'
? {
manage: {
available: record.available,
pendingMembers: pendingMembers ?? 0,
...(inactive !== null ? { inactiveEnforceAt: inactive } : {})
}
}
: {})
}
}
export function normalizePendingMembers(value: unknown): OrcaTeamMfaPendingMember[] {
const record = isRecord(value) ? value : null
const members = Array.isArray(record?.members) ? record.members : []
return members.flatMap((entry): OrcaTeamMfaPendingMember[] => {
const member = isRecord(entry) ? entry : null
const email = typeof member?.email === 'string' ? member.email.trim() : ''
if (!member || !email) {
return []
}
const displayName = typeof member.displayName === 'string' ? member.displayName.trim() : ''
return [
{
userId: typeof member.userId === 'string' && member.userId ? member.userId : null,
email,
...(displayName ? { displayName } : {}),
mfa: member.mfa === 'blocked' ? 'blocked' : member.mfa === 'pending' ? 'pending' : 'off'
}
]
})
}
async function request(url: string, init: RequestInit): Promise<unknown> {
const response = await fetch(url, init)
if (!response.ok) {
throw new OrcaCloudRequestError(response.status, await extractErrorCode(response))
}
const body: unknown = await response.json()
return body
}
type Unavailable = Extract<
OrcaTeamMfaPolicyResult,
{
status:
| 'unconfigured'
| 'reconnect-required'
| 'unsupported'
| 'forbidden'
| 'rate-limited'
| 'failed'
}
>
function unavailable(result: Exclude<OrgCallResult<unknown>, { status: 'ok' }>): Unavailable {
if (result.status === 'reconnect-required') {
return { status: 'reconnect-required' }
}
if (result.status === 'failed') {
return { status: 'failed', error: result.error }
}
const { statusCode, errorCode, message } = result.error
if (statusCode === 404 && !errorCode) {
// No JSON error: an auth deployment from before these routes.
return { status: 'unsupported' }
}
if (statusCode === 403) {
return { status: 'forbidden' }
}
if (statusCode === 429) {
return { status: 'rate-limited' }
}
return { status: 'failed', error: message }
}
async function call<T>(
userDataPath: string,
run: (apiBaseUrl: string, accessToken: string, url: (path: string) => string) => Promise<T>,
orgId: string
): Promise<OrgCallResult<T> | { status: 'unconfigured' } | { status: 'unsupported' }> {
const active = ensureActiveOrcaProfile(userDataPath)
// Local dev auth has no server, so no policy.
if (isOrcaCloudDevAuthEnabled()) {
return { status: 'unsupported' }
}
const configState = getOrcaCloudAuthConfig()
if (!configState.configured) {
return { status: 'unconfigured' }
}
const { config } = configState
return runOrgMemberCall(config, active, userDataPath, (session) =>
run(config.apiBaseUrl, session.accessToken, (path) => orgMembersUrl(config, orgId, path))
)
}
export async function getOrcaTeamMfaPolicy(
userDataPath: string,
orgId: string
): Promise<OrcaTeamMfaPolicyResult> {
const result = await call(
userDataPath,
async (apiBaseUrl, token, url) =>
normalizeTeamMfaPolicy(
await request(url('/mfa-policy'), requestInit('GET', token)),
apiBaseUrl
),
orgId
)
if (result.status === 'ok') {
return { status: 'ok', ...result.value }
}
return result.status === 'unconfigured' || result.status === 'unsupported'
? result
: unavailable(result)
}
export async function setOrcaTeamMfaPolicy(
userDataPath: string,
args: { orgId: string; enforce: OrcaTeamMfaGrace | 'off' }
): Promise<OrcaTeamMfaPolicySetResult> {
if (args.enforce !== 'off' && !ORCA_TEAM_MFA_GRACE_CHOICES.includes(args.enforce)) {
return { status: 'failed', error: 'invalid_enforce' }
}
const result = await call(
userDataPath,
async (_apiBaseUrl, token, url) => {
const init =
args.enforce === 'off'
? { ...requestInit('GET', token), method: 'DELETE' }
: { ...requestInit('POST', token, { enforce: args.enforce }), method: 'PUT' }
const answer = await request(url('/mfa-policy'), init)
const body = isRecord(answer) ? answer : null
return {
policy: normalizeDeadline(body?.policy),
pendingMembers: finiteNumber(body?.pendingMembers) ?? 0
}
},
args.orgId
)
if (result.status === 'ok') {
return { status: 'ok', ...result.value }
}
if (result.status === 'unconfigured' || result.status === 'unsupported') {
return result
}
if (result.status === 'request-error') {
const { errorCode } = result.error
if (errorCode === 'actor_needs_mfa') {
return { status: 'actor-needs-mfa' }
}
if (errorCode === 'mfa_enforcement_not_entitled') {
return { status: 'not-entitled' }
}
}
return unavailable(result)
}
export async function listOrcaTeamMfaPending(
userDataPath: string,
orgId: string
): Promise<OrcaTeamMfaPendingResult> {
const result = await call(
userDataPath,
async (_apiBaseUrl, token, url) =>
normalizePendingMembers(await request(url('/mfa-policy/pending'), requestInit('GET', token))),
orgId
)
if (result.status === 'ok') {
return { status: 'ok', members: result.value }
}
return result.status === 'unconfigured' || result.status === 'unsupported'
? result
: unavailable(result)
}
export async function remindOrcaTeamMfa(
userDataPath: string,
args: { orgId: string; userId?: string }
): Promise<OrcaTeamMfaRemindResult> {
const result = await call(
userDataPath,
async (_apiBaseUrl, token, url) => {
const answer = await request(
url('/mfa-policy/remind'),
requestInit('POST', token, args.userId ? { userId: args.userId } : {})
)
const body = isRecord(answer) ? answer : null
const delivery: 'log' | 'test-inbox' | 'unknown' =
body?.delivery === 'log' || body?.delivery === 'test-inbox' ? body.delivery : 'unknown'
return { recipients: finiteNumber(body?.recipients) ?? 0, delivery }
},
args.orgId
)
if (result.status === 'ok') {
return { status: 'ok', ...result.value }
}
if (result.status === 'unconfigured' || result.status === 'unsupported') {
return result
}
if (result.status === 'request-error') {
if (result.error.errorCode === 'no_policy') {
return { status: 'no-policy' }
}
if (result.error.errorCode === 'member_not_found') {
return { status: 'not-found' }
}
}
return unavailable(result)
}
@@ -32,7 +32,8 @@ function devSelf(): OrcaOrgMember {
userId: cleanEnvString(process.env.ORCA_CLOUD_DEV_USER_ID, 'dev-user'),
email: cleanEnvString(process.env.ORCA_CLOUD_DEV_EMAIL, 'dev@orca.local'),
displayName: cleanEnvString(process.env.ORCA_CLOUD_DEV_DISPLAY_NAME, 'Orca Dev'),
role: 'owner'
role: 'owner',
mfa: 'on'
}
}
@@ -44,10 +45,17 @@ function seedDevRoster(): DevOrgRoster {
userId: 'dev-teammate-1',
email: 'teammate@orca.local',
displayName: 'Dev Teammate',
role: 'admin'
role: 'admin',
mfa: 'off'
},
// Null user IDs exercise members who have not signed in yet.
{ userId: null, email: 'invited-member@orca.local', displayName: undefined, role: 'member' }
{
userId: null,
email: 'invited-member@orca.local',
displayName: undefined,
role: 'member',
mfa: 'off'
}
],
pendingInvites: [{ email: 'pending@orca.local', role: 'member', createdAt: Date.now() }]
}
@@ -1,3 +1,4 @@
import type { OrcaOrgMemberMfa } from '../../../shared/orca-account-mfa'
import type {
OrcaOrgMember,
OrcaOrgMembersRoster,
@@ -53,6 +54,22 @@ function optionalPictureUrl(value: unknown): string | undefined {
}
}
const MEMBER_MFA: readonly OrcaOrgMemberMfa[] = ['on', 'off', 'pending']
// Absent for plain members (the server leaves it out); an unknown value is dropped, never guessed.
function normalizeMemberMfa(
record: Record<string, unknown>
): Pick<OrcaOrgMember, 'mfa' | 'mfaDeadline'> {
const mfa = MEMBER_MFA.find((status) => status === record.mfa)
if (!mfa) {
return {}
}
const deadline = record.mfaDeadline
return mfa === 'pending' && typeof deadline === 'number' && Number.isFinite(deadline)
? { mfa, mfaDeadline: deadline }
: { mfa }
}
function normalizeMember(value: unknown): OrcaOrgMember | null {
if (!value || typeof value !== 'object') {
return null
@@ -70,7 +87,8 @@ function normalizeMember(value: unknown): OrcaOrgMember | null {
...(optionalPictureUrl(record.pictureUrl)
? { pictureUrl: optionalPictureUrl(record.pictureUrl) }
: {}),
role: normalizeRole(record.role, 'member')
role: normalizeRole(record.role, 'member'),
...normalizeMemberMfa(record)
}
}
@@ -29,4 +29,30 @@ describe('normalizeRoster', () => {
])
expect('pictureUrl' in roster.members[4]!).toBe(false)
})
it('keeps a known MFA status and drops anything else', () => {
const roster = normalizeRoster({
viewerRole: 'owner',
canManageMembers: true,
pendingInvites: [],
members: [
{ userId: 'a', email: 'a@x.dev', role: 'owner', mfa: 'on' },
{ userId: 'b', email: 'b@x.dev', role: 'member', mfa: 'off', mfaDeadline: 5 },
{ userId: 'c', email: 'c@x.dev', role: 'member', mfa: 'pending', mfaDeadline: 1_800_000 },
{ userId: 'd', email: 'd@x.dev', role: 'member', mfa: 'pending', mfaDeadline: 'soon' },
{ userId: 'e', email: 'e@x.dev', role: 'member', mfa: true },
{ userId: 'f', email: 'f@x.dev', role: 'member' }
]
})
expect(roster.members.map((m) => [m.mfa, m.mfaDeadline])).toEqual([
['on', undefined],
// A deadline only means something while the member is pending.
['off', undefined],
['pending', 1_800_000],
['pending', undefined],
[undefined, undefined],
[undefined, undefined]
])
expect('mfa' in roster.members[5]!).toBe(false)
})
})
+5 -2
View File
@@ -47,8 +47,11 @@ export type EphemeralVmApi = {
diagnostics: NonNullable<OrcaHooks['environmentRecipeDiagnostics']>
}[]
>
/** Names (never values) of this computer's env that recipe create scripts receive. */
forwardedEnvSummary: () => Promise<RecipeForwardedEnvSummary>
/**
* Names (never values) of this computer's env that recipe scripts receive. Given a recipe host's
* environmentId, main applies that recipe's passEnv; otherwise the whole env.
*/
forwardedEnvSummary: (args?: { environmentId?: string }) => Promise<RecipeForwardedEnvSummary>
/** Credential-like variable names (never values) recipe scripts would inherit from Orca. */
listCredentialEnvNames: () => Promise<string[]>
doctor: (args: { repoId: string; recipeId: string }) => Promise<EphemeralVmRecipeDoctorResult>
+1 -1
View File
@@ -14,7 +14,7 @@ import {
export const ephemeralVmApi = {
listRecipes: (args) => ipcRenderer.invoke('ephemeralVm:listRecipes', args),
listRecipeCatalog: () => ipcRenderer.invoke('ephemeralVm:listRecipeCatalog'),
forwardedEnvSummary: () => ipcRenderer.invoke('ephemeralVm:forwardedEnvSummary'),
forwardedEnvSummary: (args) => ipcRenderer.invoke('ephemeralVm:forwardedEnvSummary', args),
listCredentialEnvNames: () => ipcRenderer.invoke('ephemeralVm:listCredentialEnvNames'),
doctor: (args) => ipcRenderer.invoke('ephemeralVm:doctor', args),
provision: (args) => ipcRenderer.invoke('ephemeralVm:provision', args),
@@ -20,7 +20,6 @@ export const orcaCloudWorkspaceApi = {
listCloudWorkspaceIds: () => ipcRenderer.invoke(CH.listCloudWorkspaceIds),
getConfig: () => ipcRenderer.invoke(CH.getConfig),
connectGitHub: (args) => ipcRenderer.invoke(CH.connectGitHub, args),
gitHubInstallLink: (args) => ipcRenderer.invoke(CH.gitHubInstallLink, args),
getGitHubUser: () => ipcRenderer.invoke(CH.getGitHubUser),
connectGitHubUser: () => ipcRenderer.invoke(CH.connectGitHubUser),
gitHubUserConnectLink: () => ipcRenderer.invoke(CH.gitHubUserConnectLink),
+17 -5
View File
@@ -1,3 +1,13 @@
import type {
OrcaTeamMfaPendingResult,
OrcaTeamMfaPolicyArgs,
OrcaTeamMfaPolicyResult,
OrcaTeamMfaPolicySetArgs,
OrcaTeamMfaPolicySetResult,
OrcaTeamMfaRemindArgs,
OrcaTeamMfaRemindResult
} from '../../shared/orca-team-mfa-policy'
import type { OrcaAccountMfaResult } from '../../shared/orca-account-mfa'
import type {
CloudSetupGetResult,
CloudSetupLinkResult,
@@ -45,7 +55,6 @@ import type {
} from '../../shared/orca-profiles'
import type {
OrcaBillingCheckoutArgs,
OrcaBillingLinkResult,
OrcaBillingOpenResult,
OrcaBillingOverageArgs,
OrcaBillingOverageResult,
@@ -85,6 +94,13 @@ export type OrcaProfileApi = {
refreshAuth: () => Promise<RefreshCurrentOrcaProfileAuthResult>
signOutCurrent: () => Promise<SignOutCurrentOrcaProfileResult>
selectOrg: (args: SelectOrcaProfileOrgArgs) => Promise<SelectOrcaProfileOrgResult>
/** The signed-in person's own two-factor state and where to manage it. */
accountMfa: () => Promise<OrcaAccountMfaResult>
/** The team's "require MFA" policy and the person's own state in it. */
teamMfaPolicy: (args: OrcaTeamMfaPolicyArgs) => Promise<OrcaTeamMfaPolicyResult>
teamMfaPolicySet: (args: OrcaTeamMfaPolicySetArgs) => Promise<OrcaTeamMfaPolicySetResult>
teamMfaPending: (args: OrcaTeamMfaPolicyArgs) => Promise<OrcaTeamMfaPendingResult>
teamMfaRemind: (args: OrcaTeamMfaRemindArgs) => Promise<OrcaTeamMfaRemindResult>
orgMembersList: (args: OrcaProfileOrgMembersListArgs) => Promise<OrcaProfileOrgMembersListResult>
orgMemberInvite: (
args: OrcaProfileOrgMemberInviteArgs
@@ -130,10 +146,6 @@ export type OrcaProfileApi = {
cloudSetupLink: (args: { sessionId: string }) => Promise<CloudSetupLinkResult>
/** Opens the Stripe Customer Portal in the browser. */
billingOpenPortal: () => Promise<OrcaBillingOpenResult>
/** "Copy link": a fresh Customer Portal URL, minted but not opened. */
billingPortalLink: () => Promise<OrcaBillingLinkResult>
/** "Copy link": the Checkout URL billingOpenCheckout would open, minted but not opened. */
billingCheckoutLink: (args: OrcaBillingCheckoutArgs) => Promise<OrcaBillingLinkResult>
/** The last 30 days of sandbox hours (breakdowns for owners and admins only). */
billingUsageHistory: (args: {
utcOffsetMinutes: number
+5 -2
View File
@@ -73,6 +73,11 @@ export const orcaProfilesApi = {
refreshAuth: () => ipcRenderer.invoke('orcaProfiles:refreshAuth'),
signOutCurrent: () => ipcRenderer.invoke('orcaProfiles:signOutCurrent'),
selectOrg: (args) => ipcRenderer.invoke('orcaProfiles:selectOrg', args),
accountMfa: () => ipcRenderer.invoke('orcaProfiles:accountMfa'),
teamMfaPolicy: (args) => ipcRenderer.invoke('orcaProfiles:teamMfaPolicy', args),
teamMfaPolicySet: (args) => ipcRenderer.invoke('orcaProfiles:teamMfaPolicySet', args),
teamMfaPending: (args) => ipcRenderer.invoke('orcaProfiles:teamMfaPending', args),
teamMfaRemind: (args) => ipcRenderer.invoke('orcaProfiles:teamMfaRemind', args),
orgMembersList: (args) => ipcRenderer.invoke('orcaProfiles:orgMembersList', args),
orgMemberInvite: (args) => ipcRenderer.invoke('orcaProfiles:orgMemberInvite', args),
orgInviteRevoke: (args) => ipcRenderer.invoke('orcaProfiles:orgInviteRevoke', args),
@@ -102,8 +107,6 @@ export const orcaProfilesApi = {
billingPlans: () => ipcRenderer.invoke('orcaProfiles:billingPlans'),
billingOpenCheckout: (args) => ipcRenderer.invoke('orcaProfiles:billingOpenCheckout', args),
billingOpenPortal: () => ipcRenderer.invoke('orcaProfiles:billingOpenPortal'),
billingPortalLink: () => ipcRenderer.invoke('orcaProfiles:billingPortalLink'),
billingCheckoutLink: (args) => ipcRenderer.invoke('orcaProfiles:billingCheckoutLink', args),
billingTeamPlans: (args) => ipcRenderer.invoke('orcaProfiles:billingTeamPlans', args),
billingUsageHistory: (args) => ipcRenderer.invoke('orcaProfiles:billingUsageHistory', args),
cloudSetupStart: (args) => ipcRenderer.invoke('orcaProfiles:cloudSetupStart', args),
@@ -45,20 +45,27 @@ function useHostKeys(hostId: ExecutionHostId): AgentApiKeySummary[] | null {
return keys
}
function useRecipeEnvSummary(enabled: boolean): RecipeForwardedEnvSummary | null | undefined {
/** Main resolves this recipe host's passEnv from its recipe; the renderer only names the host. */
function useRecipeEnvSummary(
enabled: boolean,
environmentId: string | null
): RecipeForwardedEnvSummary | null | undefined {
const [summary, setSummary] = useState<RecipeForwardedEnvSummary | null | undefined>(null)
useEffect(() => {
if (!enabled) {
return
}
let cancelled = false
void (window.api.ephemeralVm?.forwardedEnvSummary() ?? Promise.resolve(undefined))
void (
window.api.ephemeralVm?.forwardedEnvSummary(environmentId ? { environmentId } : undefined) ??
Promise.resolve(undefined)
)
.catch(() => undefined)
.then((next) => !cancelled && setSummary(next))
return () => {
cancelled = true
}
}, [enabled])
}, [enabled, environmentId])
return summary
}
@@ -132,7 +139,7 @@ export function useHostPanelBody(
// A primitive snapshot so the selector stays stable between renders.
return `${accounts.claude ?? ''}\u0000${accounts.codex ?? ''}`
})
const recipeSummary = useRecipeEnvSummary(host.kind === 'recipe')
const recipeSummary = useRecipeEnvSummary(host.kind === 'recipe', host.environmentId)
const [signOutAgent, setSignOutAgent] = useState<HostAgentSignInAgent | null>(null)
const unavailable = host.availability !== 'available'
const agents = (
@@ -4,7 +4,8 @@ import { RecipeEnvForwardingWarning } from './RecipeEnvForwardingWarning'
const summary = {
count: 42,
keyLike: ['ANTHROPIC_API_KEY', 'GITHUB_TOKEN', 'NPM_TOKEN'],
other: ['EDITOR', 'HOME', 'LANG', 'PATH', 'SHELL', 'TERM', 'USER']
other: ['EDITOR', 'HOME', 'LANG', 'PATH', 'SHELL', 'TERM', 'USER'],
narrowed: false
}
export const warning = defineFixture({
@@ -29,6 +30,22 @@ export const manyKeys = defineFixture({
)
})
// A recipe with `passEnv: ['AWS_*']`: only base variables plus the AWS ones reach its scripts.
export const narrowed = defineFixture({
width: 420,
render: () => (
<RecipeEnvForwardingWarning
summary={{
count: 6,
keyLike: ['AWS_SECRET_ACCESS_KEY'],
other: ['HOME', 'LANG', 'PATH', 'SHELL', 'USER'],
narrowed: true
}}
defaultReviewOpen
/>
)
})
export const noKeys = defineFixture({
width: 420,
render: () => <RecipeEnvForwardingWarning summary={{ ...summary, keyLike: [] }} />
@@ -0,0 +1,25 @@
// @vitest-environment happy-dom
import { cleanup, render, screen } from '@testing-library/react'
import { afterEach, expect, it } from 'vitest'
import { RecipeEnvForwardingWarning } from './RecipeEnvForwardingWarning'
afterEach(cleanup)
const summary = { count: 2, keyLike: ['AWS_SECRET_ACCESS_KEY'], other: ['PATH'] }
it('says the recipe gets only what its passEnv allows, with passEnv as code', () => {
render(<RecipeEnvForwardingWarning summary={{ ...summary, narrowed: true }} />)
const code = screen.getByText('passEnv')
expect(code.tagName).toBe('CODE')
expect(code.parentElement?.textContent).toBe(
"This recipe's create script gets only the variables its passEnv allows."
)
expect(screen.queryByText(/this computer's environment/)).toBeNull()
})
it("keeps the whole-environment headline when passEnv didn't apply", () => {
render(<RecipeEnvForwardingWarning summary={{ ...summary, narrowed: false }} />)
expect(
screen.getByText("This recipe's create script gets this computer's environment.")
).toBeTruthy()
})
@@ -1,6 +1,8 @@
import { TriangleAlert } from 'lucide-react'
import type React from 'react'
import { useEffect, useId, useState } from 'react'
import { Trans } from 'react-i18next'
import { i18n } from '@/i18n/i18n'
import { useTranslate } from '@/i18n/use-translate'
import { Button } from '../ui/button'
import { Skeleton } from '../ui/skeleton'
@@ -9,8 +11,9 @@ import type { RecipeForwardedEnvSummary } from '../../../../shared/ephemeral-vm-
const NAMES_IN_LINE = 3
/**
* P-4 (agent accounts spec §4, Q9): recipe create scripts get this computer's whole environment.
* A warning only; names, never values. `summary` null while loading, undefined when unavailable.
* P-4 (agent accounts spec §4, Q9): recipe create scripts get this computer's environment, or only
* what the recipe's passEnv allows (`summary.narrowed`). A warning only; names, never values.
* `summary` null while loading, undefined when unavailable.
*/
export function RecipeEnvForwardingWarning({
summary,
@@ -70,9 +73,21 @@ export function RecipeEnvForwardingWarning({
<TriangleAlert className="mt-0.5 size-4 shrink-0 text-status-warning" aria-hidden />
<div className="min-w-0 flex-1 space-y-0.5">
<p className="text-sm font-medium text-foreground">
{t(
'agentHostPanel.recipeEnv',
"This recipe's create script gets this computer's environment."
{summary?.narrowed ? (
// passEnv is an orca.yaml key, so it reads as code rather than a word.
<Trans
i18n={i18n}
defaults={t(
'agentHostPanel.recipeEnvNarrowed',
"This recipe's create script gets only the variables its <code>passEnv</code> allows."
)}
components={{ code: <code className="rounded bg-muted px-1 py-0.5 font-mono" /> }}
/>
) : (
t(
'agentHostPanel.recipeEnv',
"This recipe's create script gets this computer's environment."
)
)}
</p>
{summary === null ? (
@@ -90,7 +90,8 @@ export function HostFixture({
summary={{
count: 42,
keyLike: ['AWS_SECRET_ACCESS_KEY', 'OPENAI_API_KEY'],
other: ['HOME', 'PATH']
other: ['HOME', 'PATH'],
narrowed: false
}}
/>
) : null
@@ -18,6 +18,7 @@ import { Button } from '@/components/ui/button'
import type { ExternalLinkSource } from '@/components/open-external/copy-external-link'
import { CloudStripPasteForm } from './CloudStripPasteForm'
import { StripPrimaryButton, stripPrimaryLink } from './CloudStripPrimaryButton'
import { CloudStripSettingsLink } from './CloudStripSettingsLink'
import {
DropdownMenu,
DropdownMenuContent,
@@ -103,6 +104,8 @@ export type CloudStripActions = {
* setup's sign-in page, known only to main). Actions carrying a `url` copy it without this.
*/
linkFor?: (action: CloudStripPrimary) => ExternalLinkSource | null
/** CHAT-RENEW-INPLACE: the model's `settingsLink` ("Renew in Settings"). */
openSettings?: () => void
}
/** GA-P3t: the strip's severity look; anything that isn't a warning or an error reads as info. */
@@ -336,6 +339,9 @@ export function CloudAgentSignInStrip({
</DropdownMenuContent>
</DropdownMenu>
) : null}
{model.settingsLink && !stacked ? (
<CloudStripSettingsLink label={model.settingsLink} onOpen={actions.openSettings} />
) : null}
{/* Renew and Restart are the whole action and the strip leaves on its own; Escape still cancels. */}
{model.noClose ||
(!model.dismiss &&
@@ -378,6 +384,13 @@ export function CloudAgentSignInStrip({
{model.primary.label}
</StripPrimaryButton>
) : null}
{model.settingsLink ? (
<CloudStripSettingsLink
ownLine
label={model.settingsLink}
onOpen={actions.openSettings}
/>
) : null}
</div>
) : null}
<span role="status" className="sr-only">
@@ -0,0 +1,136 @@
// CHAT-RENEW-INPLACE: the in-place renewal, step by step, on all three surfaces (a launch held on the
// expired sign-in, a running terminal, a structured chat). design-squad's per-step copy.
import React from 'react'
import { defineFixture } from '../../component-fixtures/component-fixture'
import { translate } from '@/i18n/i18n'
import type { OrcaCloudAgentSetup } from '../../../../shared/orca-cloud-agents/orca-cloud-agents-wire'
import {
CloudAgentSignInStrip,
CloudStripLayer,
cloudStripWidth,
type CloudStripActions
} from './CloudAgentSignInStrip'
import type { CloudStripModel } from './cloud-agent-strip-model'
import { cloudAgentStripModel } from './cloud-agent-strip-model'
import { cloudAgentAwaitingStartStripModel } from './cloud-agent-setup-strip-model'
import { cloudChatRunningStripModel, cloudRunningStripModel } from './cloud-running-strip-model'
import { cloudRenewInPlaceModel } from './cloud-renew-in-place'
const noop = (): void => {}
const ACTIONS: CloudStripActions = {
primary: noop,
submitCode: noop,
pasteCode: noop,
useCode: noop,
useApiKey: noop,
cancel: noop,
openSettings: noop
}
type Surface = 'held' | 'terminal' | 'chat'
type Step = 'expired' | 'browser' | 'checking' | 'rejected' | 'renewed'
const SETUP: Record<Exclude<Step, 'renewed'>, OrcaCloudAgentSetup> = {
expired: { phase: 'idle' },
browser: { phase: 'browser', startedAt: 0, canReopen: true, acceptsCode: true },
checking: {
phase: 'browser',
startedAt: 0,
canReopen: true,
acceptsCode: true,
code: 'checking'
},
rejected: { phase: 'browser', startedAt: 0, canReopen: true, acceptsCode: true, code: 'rejected' }
}
function expiredModel(surface: Surface): CloudStripModel {
const strip = { phase: 'expired' as const, agent: 'claude' as const }
return surface === 'held'
? cloudAgentStripModel({
agent: 'claude',
reason: 'accountExpired',
view: null,
hostLabel: '',
t: translate
})
: surface === 'chat'
? cloudChatRunningStripModel(strip, translate)
: cloudRunningStripModel(strip, translate)
}
function stepModel(surface: Surface, step: Step): CloudStripModel {
if (step !== 'renewed') {
return cloudRenewInPlaceModel({
agent: 'claude',
expired: expiredModel(surface),
setup: SETUP[step],
t: translate
})
}
const renewed = { phase: 'renewed' as const, agent: 'claude' as const, resumable: true }
// Step 5 is each surface's own: held waits for Start (team-lead B), the terminal offers Restart
// (RA-11), the chat's next message uses the renewed sign-in.
return surface === 'held'
? cloudAgentAwaitingStartStripModel({
agent: 'claude',
awaiting: 'renewed',
queuedPrompt: true,
t: translate
})
: surface === 'chat'
? cloudChatRunningStripModel(renewed, translate)
: cloudRunningStripModel(renewed, translate)
}
function Frame({
surface,
step,
width
}: {
surface: Surface
step: Step
width: number
}): React.JSX.Element {
return (
<div className="bg-background p-4">
<div
className="relative h-[220px] overflow-hidden rounded-md border border-border bg-background"
style={{ width }}
>
<CloudStripLayer>
<CloudAgentSignInStrip
model={stepModel(surface, step)}
prompt={surface === 'held' ? 'Fix the flaky auth test and open a PR' : null}
width={cloudStripWidth(width)}
actions={ACTIONS}
/>
</CloudStripLayer>
</div>
</div>
)
}
const fixture = (surface: Surface, step: Step, width = 900) =>
defineFixture({
width: width + 40,
render: () => <Frame surface={surface} step={step} width={width} />
})
export const heldExpired = fixture('held', 'expired')
export const heldBrowser = fixture('held', 'browser')
export const heldChecking = fixture('held', 'checking')
export const heldRejected = fixture('held', 'rejected')
export const heldRenewed = fixture('held', 'renewed')
export const terminalExpired = fixture('terminal', 'expired')
export const terminalBrowser = fixture('terminal', 'browser')
export const terminalChecking = fixture('terminal', 'checking')
export const terminalRejected = fixture('terminal', 'rejected')
export const terminalRenewed = fixture('terminal', 'renewed')
export const chatExpired = fixture('chat', 'expired')
export const chatBrowser = fixture('chat', 'browser')
export const chatChecking = fixture('chat', 'checking')
export const chatRejected = fixture('chat', 'rejected')
export const chatRenewed = fixture('chat', 'renewed')
/** Narrow: the code field stacks under the text, and "Renew in Settings" gets its own line. */
export const chatBrowserNarrow = fixture('chat', 'browser', 440)
export const terminalRejectedNarrow = fixture('terminal', 'rejected', 440)
@@ -49,7 +49,14 @@ vi.mock('@/lib/orca-cloud/orca-cloud-environment-id', () => ({
}))
vi.mock('@/lib/orca-cloud/orca-cloud-agent-accounts-store', () => ({
orcaCloudAgentAccountsLoadedAt: () => 0,
useOrcaCloudAgentAccounts: () => ({ load: { kind: 'loading' }, keyKinds: {} })
useOrcaCloudAgentAccounts: () => ({
load: { kind: 'loading' },
keyKinds: {},
setups: { claude: { phase: 'idle' }, codex: { phase: 'idle' } }
}),
runOrcaCloudAgentSetups: () => undefined,
stopOrcaCloudAgentSetups: () => undefined,
reloadOrcaCloudAgentAccounts: async () => undefined
}))
vi.mock('@/lib/orca-cloud/cloud-running-agent-signout', () => ({
clearCloudRunningSignout: () => undefined,
@@ -42,6 +42,7 @@ import {
cloudRestartFreshModel,
cloudRunningStripModel
} from './cloud-running-strip-model'
import { openOrcaCloudAccountsSettings, withRenewInPlace } from './cloud-renew-in-place'
const NO_ACTIONS: CloudStripActions = {
primary: () => undefined,
@@ -52,12 +53,6 @@ const NO_ACTIONS: CloudStripActions = {
cancel: () => undefined
}
function openAccounts(): void {
const store = useAppStore.getState()
store.openSettingsTarget({ pane: 'accounts', repoId: null, sectionId: 'orca-cloud' })
store.openSettingsPage()
}
export function CloudRunningStripPortal({
pane,
tabId,
@@ -192,7 +187,7 @@ export function CloudRunningStripPortal({
const actions: CloudStripActions = {
primary: (action) => {
if (action.kind === 'renew') {
openAccounts()
openOrcaCloudAccountsSettings()
} else if (action.kind === 'restart' && strip.phase === 'renewed') {
restart({ agent: strip.agent, resumable: strip.resumable })
}
@@ -204,6 +199,19 @@ export function CloudRunningStripPortal({
// State 2's ×; state 1 has none (Renew is the action) and Escape leaves it showing.
cancel: () => (strip.phase === 'renewed' ? clearCloudRunningSignout(paneKey) : undefined)
}
// CHAT-RENEW-INPLACE: "sign-in expired · Renew" renews right here; renewed keeps RA-11's Restart.
const model = cloudRunningStripModel(strip, t)
const shown =
strip.phase === 'expired'
? withRenewInPlace({
agent: strip.agent,
setup: accounts.setups[strip.agent],
model,
actions,
key: paneKey,
t
})
: { model, actions }
return (
<CloudPaneBannerPortal
pane={pane}
@@ -212,10 +220,10 @@ export function CloudRunningStripPortal({
stripLayer
>
<CloudAgentSignInStrip
model={cloudRunningStripModel(strip, t)}
model={shown.model}
prompt={null}
width={cloudStripWidth(pane.container.clientWidth)}
actions={actions}
actions={shown.actions}
/>
</CloudPaneBannerPortal>
)
@@ -0,0 +1,35 @@
import React from 'react'
import { cn } from '@/lib/class-names'
/**
* CHAT-RENEW-INPLACE: the strip's quiet "Renew in Settings" link, at the end of the actions row, or on
* its own line under the buttons in the narrow stack (design-squad).
*/
export function CloudStripSettingsLink({
label,
onOpen,
ownLine = false
}: {
label: string
onOpen?: () => void
ownLine?: boolean
}): React.JSX.Element | null {
if (!onOpen) {
return null
}
return (
<button
type="button"
data-strip-settings-link
onClick={onOpen}
className={cn(
// The quiet-link rule: underlined at rest (muted), stronger on hover, a visible focus ring.
'shrink-0 cursor-pointer text-xs text-muted-foreground underline decoration-muted-foreground/50 underline-offset-2 hover:text-foreground hover:decoration-foreground',
'rounded-sm outline-none focus-visible:ring-2 focus-visible:ring-ring',
ownLine && 'basis-full text-left'
)}
>
{label}
</button>
)
}
@@ -22,16 +22,19 @@ function tabStillOpen(tabId: string): boolean {
export function CloudStructuredChatBanners({
tabId,
paneKey,
statusKey
statusKey,
agent
}: {
tabId: string
/** The launch-hold key (from the session id). */
paneKey: string
/** The agent-status key (tab and session): the running strip (B2) reads the agent through it. */
statusKey: string
/** The chat's agent, for an idle chat with no status yet. */
agent?: string
}): React.JSX.Element {
const { key, active, strip } = useCloudHeldStrip(paneKey, null, { chat: true })
const running = useCloudChatRunningStrip({ tabId, statusKey, holdKey: paneKey })
const running = useCloudChatRunningStrip({ tabId, statusKey, holdKey: paneKey, agent })
const shown = strip ?? running
useEffect(() => {
if (!active) {
@@ -5,11 +5,11 @@ import { cloudAgentStripModel } from './cloud-agent-strip-model'
const base = { agent: 'claude' as const, hostLabel: 'the sandbox', t: translate }
describe('cloudAgentStripModel', () => {
it('account recovery (S4-c): Renew, account-level wording, no per-workspace words', () => {
it('account recovery (S4-c), held: Renew, "Renew to start Claude." (CHAT-RENEW-INPLACE copy)', () => {
const model = cloudAgentStripModel({ ...base, reason: 'accountExpired', view: null })
expect(model).toMatchObject({
title: 'Your Claude sign-in expired',
detail: 'Sign in once to fix every workspace.',
detail: 'Renew to start Claude.',
primary: { label: 'Renew', action: { kind: 'renew' } }
})
})
@@ -57,6 +57,11 @@ export type CloudStripModel = {
otherWays: boolean
/** Already on a code: ⋯ offers the paste fallback and Cancel instead of "Use a code". */
codeStep?: boolean
/**
* CHAT-RENEW-INPLACE: a quiet text link at the end of the actions row ("Renew in Settings"); in
* the narrow stack it gets its own line under the buttons.
*/
settingsLink?: string
/** RA-11 state 2: a dismiss × with this label (the strip otherwise drops its × on Renew). */
dismiss?: string
/** RA-11 "Restarting…": nothing to close; the strip leaves with the result. */
@@ -121,15 +126,15 @@ export function cloudAgentStripModel(args: {
return {
status: 'warning',
title: t('agentSignInStrip.expired', 'Your {{agent}} sign-in expired', { agent }),
detail: t('agentSignInStrip.expiredDetail', 'Sign in once to fix every workspace.'),
detail: t('agentSignInStrip.expiredHeldDetail', 'Renew to start {{agent}}.', { agent }),
description: null,
primary: { label: t('agentSignInStrip.renew', 'Renew'), action: { kind: 'renew' } },
code: null,
paste: null,
otherWays: false,
announcement: t(
'agentSignInStrip.expiredAnnounce',
'Your {{agent}} sign-in expired. Renew it once to fix every workspace.',
'agentSignInStrip.expiredHeldAnnounce',
'Your {{agent}} sign-in expired. Renew to start {{agent}}.',
{ agent }
)
}
@@ -2,7 +2,7 @@
// CHAT-BANNERS B2: RA-11's running strip on a structured chat. Expired shows Renew; renewed confirms
// with no Restart (the chat's next message uses the renewed sign-in) and its × dismisses; a held
// launch's strip wins over it.
import { cleanup, fireEvent, render, screen } from '@testing-library/react'
import { cleanup, fireEvent, render, renderHook, screen } from '@testing-library/react'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { TooltipProvider } from '@/components/ui/tooltip'
@@ -21,7 +21,8 @@ const stub = vi.hoisted(() => {
cleared: string[]
calls: { paneKey: string; turnEndedFallback?: boolean }[]
openedSettings: number
} = { strip: null, held: false, cleared: [], calls: [], openedSettings: 0 }
renewsRun: string[][]
} = { strip: null, held: false, cleared: [], calls: [], openedSettings: 0, renewsRun: [] }
return state
})
@@ -47,6 +48,9 @@ vi.mock('@/lib/orca-cloud/orca-cloud-environment-id', () => ({
}))
vi.mock('@/lib/orca-cloud/orca-cloud-agent-accounts-store', () => ({
orcaCloudAgentAccountsLoadedAt: () => 1,
runOrcaCloudAgentSetups: (agents: string[]) => stub.renewsRun.push(agents),
stopOrcaCloudAgentSetups: () => undefined,
reloadOrcaCloudAgentAccounts: async () => undefined,
useOrcaCloudAgentAccounts: () => ({
load: { kind: 'loading' },
keyKinds: {},
@@ -94,6 +98,7 @@ vi.stubGlobal(
)
const { CloudStructuredChatBanners } = await import('./CloudStructuredChatBanners')
const { useCloudChatSendBlock } = await import('./use-cloud-chat-running-strip')
const mount = () =>
render(
@@ -117,7 +122,9 @@ describe('the running strip on a structured chat (B2)', () => {
mount()
expect(screen.getAllByText(/Claude sign-in expired/).length).toBeGreaterThan(0)
fireEvent.click(screen.getByRole('button', { name: /Renew/ }))
expect(stub.openedSettings).toBe(1)
// CHAT-RENEW-INPLACE: Renew runs the renewal right here, never Settings.
expect(stub.renewsRun).toEqual([['claude']])
expect(stub.openedSettings).toBe(0)
expect(stub.calls.at(-1)).toEqual({ paneKey: STATUS_KEY, turnEndedFallback: true })
})
@@ -139,3 +146,54 @@ describe('the running strip on a structured chat (B2)', () => {
expect(screen.queryByRole('button', { name: /Renew/ })).toBeNull()
})
})
describe('an idle chat (no message yet, no status entry)', () => {
const IDLE_TAB = 'structured-agent-session-claude_idle'
const idle = () =>
render(
<TooltipProvider>
<CloudStructuredChatBanners
tabId={TAB_ID}
paneKey={HOLD_KEY}
statusKey={`${IDLE_TAB}:no-status`}
agent="claude"
/>
</TooltipProvider>
)
it("expired account: the strip shows, decided from the chat's own agent", () => {
stub.strip = { phase: 'expired', agent: 'claude' }
idle()
expect(screen.getAllByText(/Claude sign-in expired/).length).toBeGreaterThan(0)
expect(stub.calls.at(-1)?.paneKey).toBe(`${IDLE_TAB}:no-status`)
})
it('covered account: no strip', () => {
idle()
expect(screen.queryByRole('region')).toBeNull()
})
it('a held launch shows the held strip instead', () => {
stub.strip = { phase: 'expired', agent: 'claude' }
stub.held = true
idle()
expect(screen.getByRole('button', { name: 'Set up once' })).toBeTruthy()
})
})
describe('Send while the account is expired', () => {
const args = { tabId: TAB_ID, statusKey: STATUS_KEY, holdKey: HOLD_KEY, agent: 'claude' }
it('expired: Send is held with the Renew hint (typing is not touched)', () => {
stub.strip = { phase: 'expired', agent: 'claude' }
const { result } = renderHook(() => useCloudChatSendBlock(args))
expect(result.current).toBe('Renew Claude sign-in above to send')
})
it('renewed or covered: Send is free again', () => {
stub.strip = { phase: 'renewed', agent: 'claude', resumable: true }
expect(renderHook(() => useCloudChatSendBlock(args)).result.current).toBeUndefined()
stub.strip = null
expect(renderHook(() => useCloudChatSendBlock(args)).result.current).toBeUndefined()
})
})
@@ -0,0 +1,153 @@
// CHAT-RENEW-INPLACE: every expired strip renews in place, with design-squad's per-step copy.
import { beforeEach, describe, expect, it, vi } from 'vitest'
import type { OrcaCloudAgentSetup } from '../../../../shared/orca-cloud-agents/orca-cloud-agents-wire'
import type { CloudStripActions } from './CloudAgentSignInStrip'
import type { CloudStripModel } from './cloud-agent-strip-model'
import { translate as t } from '@/i18n/i18n'
const store = vi.hoisted(() => ({ run: vi.fn(), stop: vi.fn() }))
vi.mock('@/lib/orca-cloud/orca-cloud-agent-accounts-store', () => ({
runOrcaCloudAgentSetups: store.run,
stopOrcaCloudAgentSetups: store.stop,
reloadOrcaCloudAgentAccounts: async () => undefined
}))
vi.mock('@/lib/orca-cloud/cloud-agent-launch-hold', () => ({
releaseCloudAgentHold: vi.fn(),
startCloudAgentHold: vi.fn()
}))
vi.mock('@/store', () => ({ useAppStore: { getState: () => ({}) } }))
vi.mock('../agent-sign-in/AgentSignInPanePortals', () => ({
agentSignInCardActions: () => ({ copyText: vi.fn(), openLink: vi.fn() })
}))
const api = vi.hoisted(() => ({ reopen: vi.fn(async () => undefined), submitClaudeCode: vi.fn() }))
vi.stubGlobal('window', { api: { orcaCloudAgents: api } })
const { cloudRenewInPlaceActions, cloudRenewInPlaceModel } = await import('./cloud-renew-in-place')
const EXPIRED: CloudStripModel = {
status: 'warning',
title: 'Your Claude sign-in expired',
detail: 'Renew to keep working. Your conversation is kept.',
description: null,
primary: { label: 'Renew', action: { kind: 'renew' } },
code: null,
paste: null,
otherWays: false,
announcement: 'Your Claude sign-in expired.'
}
const model = (setup: OrcaCloudAgentSetup) =>
cloudRenewInPlaceModel({ agent: 'claude', expired: EXPIRED, setup, t })
describe('cloudRenewInPlaceModel (design-squad per-step copy)', () => {
it("1 expired: the surface's own strip, [Renew], no Settings link", () => {
expect(model({ phase: 'idle' })).toBe(EXPIRED)
expect(model({ phase: 'saved' })).toBe(EXPIRED)
})
it('2 browser: same title, paste code, [Finish renewing] [Open again], "Renew in Settings"', () => {
const shown = model({ phase: 'browser', startedAt: 0, canReopen: true, acceptsCode: true })
expect(shown.title).toBe('Your Claude sign-in expired')
expect(shown.detail).toBe('Finish in your browser, then paste the code here.')
expect(shown.paste?.setupCode).toEqual({
placeholder: 'Paste code',
submitLabel: 'Finish renewing'
})
expect(shown.primary).toMatchObject({ label: 'Open again', action: { kind: 'reopenSetup' } })
expect(shown.settingsLink).toBe('Renew in Settings')
expect(JSON.stringify(shown)).not.toContain('Finish setup')
})
it('3 checking: the field and its button disabled', () => {
const shown = model({
phase: 'browser',
startedAt: 0,
canReopen: true,
acceptsCode: true,
code: 'checking'
})
expect(shown.paste).toMatchObject({ submitting: true })
expect(shown.paste?.setupCode?.submitLabel).toBe('Checking the code…')
})
it('4 rejected: "Code didn\'t work", the newest-code detail, [Open again] and the Settings link', () => {
const shown = model({
phase: 'browser',
startedAt: 0,
canReopen: true,
acceptsCode: true,
code: 'rejected'
})
expect(shown.title).toBe('Code didn’t work')
expect(shown.detail).toBe('Paste the newest code from the sign-in page, or open it again.')
expect(shown.paste?.refusal).toBeTruthy()
expect(shown.primary?.action.kind).toBe('reopenSetup')
expect(shown.settingsLink).toBe('Renew in Settings')
})
it('a setup that failed outright starts again from Renew', () => {
const shown = model({ phase: 'failed', error: 'denied' })
expect(shown.status).toBe('error')
expect(shown.primary?.action.kind).toBe('renew')
})
})
describe('cloudRenewInPlaceActions', () => {
const surface = (): CloudStripActions => ({
primary: vi.fn(),
submitCode: vi.fn(),
pasteCode: vi.fn(),
useCode: vi.fn(),
useApiKey: vi.fn(),
cancel: vi.fn()
})
const actions = (setup: OrcaCloudAgentSetup, own = surface(), openSettings = vi.fn()) => ({
own,
openSettings,
built: cloudRenewInPlaceActions({
agent: 'claude',
setup,
surface: own,
openSettings,
copyText: vi.fn(),
openLink: vi.fn()
})
})
beforeEach(() => {
store.run.mockClear()
store.stop.mockClear()
api.reopen.mockClear()
})
it('Renew runs the setup here (never the Settings page or the sign-in sheet)', () => {
const { built, own, openSettings } = actions({ phase: 'idle' })
built.primary({ kind: 'renew' })
expect(store.run).toHaveBeenCalledExactlyOnceWith(['claude'])
expect(own.primary).not.toHaveBeenCalled()
expect(openSettings).not.toHaveBeenCalled()
})
it('Open again reopens the setup page; "Renew in Settings" opens Settings', () => {
const { built, openSettings } = actions({ phase: 'browser', startedAt: 0, canReopen: true })
built.primary({ kind: 'reopenSetup' })
expect(api.reopen).toHaveBeenCalledExactlyOnceWith({ agent: 'claude' })
built.openSettings?.()
expect(openSettings).toHaveBeenCalledOnce()
})
it('6: × mid-flow stops the setup (back to step 1) and never dismisses the strip', () => {
const { built, own } = actions({ phase: 'browser', startedAt: 0, canReopen: true })
built.cancel()
expect(store.stop).toHaveBeenCalledExactlyOnceWith('claude')
expect(own.cancel).not.toHaveBeenCalled()
})
it('outside a renewal, the surface keeps its own × and Restart', () => {
const { built, own } = actions({ phase: 'idle' })
built.cancel()
built.primary({ kind: 'restart' })
expect(store.stop).not.toHaveBeenCalled()
expect(own.cancel).toHaveBeenCalledOnce()
expect(own.primary).toHaveBeenCalledExactlyOnceWith({ kind: 'restart' })
})
})
@@ -0,0 +1,161 @@
// CHAT-RENEW-INPLACE (Option A, design-squad per-step copy): every "sign-in expired" strip — a held
// launch, a running terminal, a structured chat — renews in place. Renew runs the same Orca Cloud
// setup as "Set up once" right in the strip (re-running it replaces the account's expired sign-in),
// instead of sending the person to Settings. One model and one set of actions for every surface, so
// the terminal and the chat can't drift apart.
// 1 expired: [Renew] 2 browser: paste code, [Finish renewing] [Open again] ×
// 3 checking: field and buttons disabled 4 rejected: "Code didn't work", [Open again]
// 5 renewed: the surface's own renewed state (held: Start; terminal: Restart; chat: next message)
// × mid-flow stops the setup and goes back to step 1; it never dismisses the strip.
import type { Translate } from '@/i18n/use-translate'
import { useAppStore } from '@/store'
import {
runOrcaCloudAgentSetups,
stopOrcaCloudAgentSetups
} from '@/lib/orca-cloud/orca-cloud-agent-accounts-store'
import type { OrcaCloudAgentSetup } from '../../../../shared/orca-cloud-agents/orca-cloud-agents-wire'
import type { HostAgentSignInAgent } from '../../../../shared/host-agent-sign-in-status'
import type { CloudStripActions } from './CloudAgentSignInStrip'
import type { CloudStripModel } from './cloud-agent-strip-model'
import { cloudAgentSetupStripModel } from './cloud-agent-setup-strip-model'
import { cloudSetupStripActions } from './cloud-setup-strip-actions'
import { agentSignInCardActions } from '../agent-sign-in/AgentSignInPanePortals'
/** The renewal's own setup is under way (steps 2-4): the strip shows it instead of step 1. */
export function renewInPlaceRunning(setup: OrcaCloudAgentSetup): boolean {
return setup.phase !== 'idle' && setup.phase !== 'saved'
}
/**
* Steps 1-4 over a surface's "expired" model (step 1 keeps the surface's own detail: running "Renew
* to keep working…", held "Renew to start {{agent}}."). Step 5 is each surface's renewed state.
*/
export function cloudRenewInPlaceModel(args: {
agent: HostAgentSignInAgent
expired: CloudStripModel
setup: OrcaCloudAgentSetup
t: Translate
}): CloudStripModel {
const { expired, setup, t } = args
if (!renewInPlaceRunning(setup)) {
return expired
}
const flow = cloudAgentSetupStripModel({ agent: args.agent, setup, ready: false, t })
const settingsLink = t('agentSignInStrip.renewInSettings', 'Renew in Settings')
// A failed setup keeps its own words; a refused code says "Code didn't work" (as #484).
const keepsTitle =
setup.phase === 'failed' || (setup.phase === 'browser' && setup.code === 'rejected')
const finishRenewing = t('agentSignInStrip.finishRenewing', 'Finish renewing')
const paste = flow.paste
? {
...flow.paste,
// Never the setup's "Finish setup" (design-squad).
...(flow.paste.setupCode
? {
setupCode: {
...flow.paste.setupCode,
submitLabel:
setup.phase === 'browser' && setup.code === 'checking'
? flow.paste.setupCode.submitLabel
: finishRenewing
}
}
: {}),
...(flow.paste.submitLabel ? { submitLabel: finishRenewing } : {})
}
: null
return {
...flow,
title: keepsTitle ? flow.title : expired.title,
paste,
// A setup that failed outright starts again from Renew.
primary:
setup.phase === 'failed' && flow.primary?.action.kind === 'setUpOnce'
? { ...flow.primary, action: { kind: 'renew' } }
: flow.primary,
...(setup.phase === 'browser' || setup.phase === 'paste' ? { settingsLink } : {}),
announcement: keepsTitle ? flow.announcement : `${expired.title}. ${flow.announcement}`
}
}
/**
* Renew starts the setup here; Open again, the code and the paste go to it; × stops it (back to
* step 1). With no renewal running, everything else is the surface's own (its × or Restart).
*/
export function cloudRenewInPlaceActions(args: {
agent: HostAgentSignInAgent
setup: OrcaCloudAgentSetup
/** The surface's own actions, used outside the renewal (Restart, a renewed strip's ×). */
surface: CloudStripActions
/** "Renew in Settings": the same renewal in Settings › Accounts › Orca Cloud. */
openSettings: () => void
copyText: (text: string) => void
openLink: (url: string) => void
}): CloudStripActions {
const running = renewInPlaceRunning(args.setup)
const flow = cloudSetupStripActions({
agent: args.agent,
// Renewing holds nothing itself: Start (step 5) belongs to the surface.
holdKey: '',
setupRunning: running,
copyText: args.copyText,
openLink: args.openLink,
useApiKey: args.surface.useApiKey,
keepHoldOnCancel: true
})
return {
...args.surface,
primary: (action) => {
if (action.kind === 'renew') {
runOrcaCloudAgentSetups([args.agent])
} else if (action.kind === 'reopenSetup' || action.kind === 'copyAndOpen') {
flow.primary(action)
} else {
args.surface.primary(action)
}
},
submitCode: running ? flow.submitCode : args.surface.submitCode,
submitSetupCode: flow.submitSetupCode,
// "Copy link" beside Open again: the renewal's sign-in page, as for "Set up once".
linkFor: running ? flow.linkFor : args.surface.linkFor,
pasteCode: running ? flow.pasteCode : args.surface.pasteCode,
openSettings: args.openSettings,
cancel: () => (running ? stopOrcaCloudAgentSetups(args.agent) : args.surface.cancel())
}
}
/** "Renew in Settings": Settings › Accounts › Orca Cloud, where the same renewal runs. */
export function openOrcaCloudAccountsSettings(): void {
const store = useAppStore.getState()
store.openSettingsTarget({ pane: 'accounts', repoId: null, sectionId: 'orca-cloud' })
store.openSettingsPage()
}
/** A surface's expired strip, renewing in place: its model (steps 1-4) and actions together. */
export function withRenewInPlace(args: {
agent: HostAgentSignInAgent
setup: OrcaCloudAgentSetup
model: CloudStripModel
actions: CloudStripActions
/** The pane or chat key, for the sign-in page's copy and open. */
key: string
t: Translate
}): { model: CloudStripModel; actions: CloudStripActions } {
const page = agentSignInCardActions(args.key)
return {
model: cloudRenewInPlaceModel({
agent: args.agent,
expired: args.model,
setup: args.setup,
t: args.t
}),
actions: cloudRenewInPlaceActions({
agent: args.agent,
setup: args.setup,
surface: args.actions,
openSettings: openOrcaCloudAccountsSettings,
copyText: page.copyText,
openLink: page.openLink
})
}
}
@@ -31,7 +31,7 @@ export function cloudSetupStripActions(args: {
keepHoldOnCancel?: boolean
}): CloudStripActions {
const { agent, holdKey } = args
const api = window.api.orcaCloudAgents
const api = window.api?.orcaCloudAgents
return {
primary: (action) => {
if (action.kind === 'setUpOnce') {
@@ -4,7 +4,10 @@
// with the renewed sign-in.
import { useAppStore } from '@/store'
import { useTranslate } from '@/i18n/use-translate'
import type { HostAgentSignInAgent } from '../../../../shared/host-agent-sign-in-status'
import {
HOST_AGENT_SIGN_IN_AGENT_NAME,
type HostAgentSignInAgent
} from '../../../../shared/host-agent-sign-in-status'
import { parseExecutionHostId } from '../../../../shared/execution-host'
import { useCloudAgentHold } from '@/lib/orca-cloud/cloud-agent-launch-hold'
import {
@@ -15,6 +18,7 @@ import { isOrcaCloudEnvironmentId } from '@/lib/orca-cloud/orca-cloud-environmen
import {
clearCloudRunningSignout,
cloudRunningStrip,
type CloudRunningStrip,
useCloudRunningAccountReads,
useCloudRunningSignoutVersion,
useWorkspaceUsesAccount
@@ -22,12 +26,7 @@ import {
import type { CloudStripActions } from './CloudAgentSignInStrip'
import type { CloudHeldStrip } from './use-cloud-held-strip'
import { cloudChatRunningStripModel } from './cloud-running-strip-model'
function openAccounts(): void {
const store = useAppStore.getState()
store.openSettingsTarget({ pane: 'accounts', repoId: null, sectionId: 'orca-cloud' })
store.openSettingsPage()
}
import { openOrcaCloudAccountsSettings, withRenewInPlace } from './cloud-renew-in-place'
/** The Orca Cloud environment a structured chat's tab runs on, or null. */
function useChatEnvironmentId(tabId: string): string | null {
@@ -43,27 +42,33 @@ function useChatEnvironmentId(tabId: string): string | null {
})
}
/**
* statusKey: the chat's agent-status key (its tab and session); holdKey: its launch-hold key. A held
* launch shows the held strip instead.
*/
export function useCloudChatRunningStrip(args: {
type ChatAccountArgs = {
tabId: string
statusKey: string
holdKey: string
}): CloudHeldStrip | null {
const t = useTranslate()
/** The chat's own agent: an idle chat (no message yet) has no status entry to name it. */
agent?: string
}
/**
* The RA-11 decision for a structured chat: expired / renewed / none. An idle chat with no status
* entry is decided from its own agent, so the strip shows as soon as the account expires, before a
* first message could fail. A held launch wins (null here).
*/
export function useCloudChatAccountStrip(args: ChatAccountArgs): CloudRunningStrip | null {
const revision = useCloudRunningSignoutVersion()
const environmentId = useChatEnvironmentId(args.tabId)
const cloud = environmentId !== null && isOrcaCloudEnvironmentId(environmentId)
const entry = useAppStore((state) =>
const status = useAppStore((state) =>
cloud ? (state.agentStatusByPaneKey[args.statusKey] ?? null) : null
)
const agentType = status?.agentType ?? args.agent
const agent: HostAgentSignInAgent | null =
entry?.agentType === 'claude' ? 'claude' : entry?.agentType === 'codex' ? 'codex' : null
const running = cloud && agent !== null
useCloudRunningAccountReads(running)
const accounts = useOrcaCloudAgentAccounts(running)
agentType === 'claude' ? 'claude' : agentType === 'codex' ? 'codex' : null
const watched = cloud && agent !== null
// Focus and the 30 s poll keep the account read fresh for any open cloud chat of an account agent.
useCloudRunningAccountReads(watched)
const accounts = useOrcaCloudAgentAccounts(watched)
// D13: only a workspace that runs the agent on the person's own account (never shared or keyed).
const credential =
agent && accounts.load.kind === 'ready' ? accounts.load.status.credentials[agent] : null
@@ -73,18 +78,19 @@ export function useCloudChatRunningStrip(args: {
credential.state !== 'expiring' &&
credential.state !== 'none'
const usesAccount = useWorkspaceUsesAccount(
running ? environmentId : null,
watched ? environmentId : null,
agent,
expired,
orcaCloudAgentAccountsLoadedAt()
)
const held = useCloudAgentHold(args.holdKey) !== null
if (!running) {
if (!watched || !agent) {
return null
}
const strip = cloudRunningStrip({
return cloudRunningStrip({
paneKey: args.statusKey,
entry,
// An idle chat (no message yet) has no status entry: decided from its own agent.
entry: status ?? { agentType: agent, state: 'waiting' },
accounts,
held,
now: orcaCloudAgentAccountsLoadedAt(),
@@ -92,11 +98,18 @@ export function useCloudChatRunningStrip(args: {
revision,
turnEndedFallback: true
})
}
/** The strip a structured chat shows for its account while its agent runs or waits idle. */
export function useCloudChatRunningStrip(args: ChatAccountArgs): CloudHeldStrip | null {
const t = useTranslate()
const strip = useCloudChatAccountStrip(args)
const accounts = useOrcaCloudAgentAccounts(strip !== null)
if (!strip) {
return null
}
const actions: CloudStripActions = {
primary: (action) => (action.kind === 'renew' ? openAccounts() : undefined),
primary: (action) => (action.kind === 'renew' ? openOrcaCloudAccountsSettings() : undefined),
submitCode: () => undefined,
pasteCode: () => undefined,
useCode: () => undefined,
@@ -104,5 +117,32 @@ export function useCloudChatRunningStrip(args: {
// Expired has no ×; renewed's × dismisses.
cancel: () => (strip.phase === 'renewed' ? clearCloudRunningSignout(args.statusKey) : undefined)
}
return { model: cloudChatRunningStripModel(strip, t), prompt: null, actions }
const model = cloudChatRunningStripModel(strip, t)
// CHAT-RENEW-INPLACE: the chat's "sign-in expired · Renew" renews right here.
const shown =
strip.phase === 'expired'
? withRenewInPlace({
agent: strip.agent,
setup: accounts.setups[strip.agent],
model,
actions,
key: args.statusKey,
t
})
: { model, actions }
return { ...shown, prompt: null }
}
/**
* While the chat's account is expired, typing stays open and only Send is held, with this hint
* (the person's draft is never lost); Renew lifts it at once.
*/
export function useCloudChatSendBlock(args: ChatAccountArgs): string | undefined {
const t = useTranslate()
const strip = useCloudChatAccountStrip(args)
return strip?.phase === 'expired'
? t('orcaCloud.chatSend.renewAbove', 'Renew {{agent}} sign-in above to send', {
agent: HOST_AGENT_SIGN_IN_AGENT_NAME[strip.agent]
})
: undefined
}
@@ -21,6 +21,11 @@ import {
cloudAgentSetupStripModel
} from './cloud-agent-setup-strip-model'
import { cloudSetupStripActions } from './cloud-setup-strip-actions'
import {
cloudRenewInPlaceActions,
cloudRenewInPlaceModel,
openOrcaCloudAccountsSettings
} from './cloud-renew-in-place'
export type CloudHeldStrip = {
model: CloudStripModel
@@ -70,7 +75,7 @@ export function useCloudHeldStrip(
const setupHold = hold?.reason === 'notSetUp' || awaiting !== null
const setup = accounts.setups[agent]
// HELD-STALE-COVERED: the setup just finished here: "is set up · Start" (the account, read fresh).
const model =
const shownBeforeRenew =
awaiting === 'setUp'
? cloudAgentSetupStripModel({ agent, setup: accounts.setups[agent], ready: true, t })
: awaiting
@@ -95,6 +100,11 @@ export function useCloudHeldStrip(
hostLabel: cloudGate?.hostLabel ?? t('agentSignInStrip.sandbox', 'the sandbox'),
t
})
// CHAT-RENEW-INPLACE: a launch held on an expired sign-in renews right here (steps 1-4).
const renewing = hold?.reason === 'accountExpired'
const model = renewing
? cloudRenewInPlaceModel({ agent, expired: shownBeforeRenew, setup, t })
: shownBeforeRenew
const setupRunning = setup.phase !== 'idle' && setup.phase !== 'saved' && setup.phase !== 'failed'
const holdActions: CloudStripActions | null = setupHold
? cloudSetupStripActions({
@@ -107,7 +117,7 @@ export function useCloudHeldStrip(
keepHoldOnCancel: chat
})
: null
const actions: CloudStripActions = holdActions ?? {
const gateOrRecovery: CloudStripActions = {
primary: (action) => {
// RA-11's restart belongs to the running-pane strip; a held launch never offers it.
if (
@@ -152,9 +162,21 @@ export function useCloudHeldStrip(
}
}
}
const actions: CloudStripActions =
holdActions ??
(renewing
? cloudRenewInPlaceActions({
agent,
setup,
surface: gateOrRecovery,
openSettings: openOrcaCloudAccountsSettings,
copyText: gateActions.copyText,
openLink: gateActions.openLink
})
: gateOrRecovery)
// A held chat's strip has nothing to cancel unless a setup is running: no × (Escape is a no-op).
const shownModel =
chat && hold && !(setupHold && setupRunning) ? { ...model, noClose: true } : model
chat && hold && !((setupHold || renewing) && setupRunning) ? { ...model, noClose: true } : model
return {
key,
active,
@@ -1,7 +1,6 @@
import { ExternalLink } from 'lucide-react'
import { Button } from '@/components/ui/button'
import { InlineError } from '@/components/ui/inline-error'
import { OpenExternalSplitButton } from '@/components/open-external/OpenExternalSplitButton'
import { billingPortalLink } from './billing-link'
import { useIntlLocale, useTranslate } from '@/i18n/use-translate'
import type { OrcaBillingEntitlement } from '../../../../shared/orca-billing'
@@ -63,20 +62,16 @@ export function PaymentIssueNotice({
}
action={
entitlement.canManageBilling ? (
<OpenExternalSplitButton
<Button
type="button"
variant="outline"
size="xs"
aria-disabled={busy || undefined}
link={billingPortalLink}
onClick={() => {
if (!busy) {
onUpdatePayment()
}
}}
onClick={busy ? undefined : onUpdatePayment}
>
{t('auto.components.billing.updatePayment', 'Update payment method')}
<ExternalLink />
</OpenExternalSplitButton>
</Button>
) : undefined
}
/>
@@ -14,8 +14,6 @@ import {
} from '../../../../shared/orca-billing'
import { openPlansPage } from './plans/plans-page-store'
import { PaymentIssueNotice } from './PaymentIssueNotice'
import { OpenExternalSplitButton } from '@/components/open-external/OpenExternalSplitButton'
import { billingPortalLink } from './billing-link'
import { OverageControls, UsageSummary } from './PlanBillingUsage'
import { denyReasonCopy, openFailureCopy, overageFailureCopy } from './plan-billing-copy'
import { PlanStatusBadge } from './PlanStatusBadge'
@@ -284,20 +282,16 @@ export function PlanBillingView({
</Button>
)}
{hasPlan && entitlement.canManageBilling && entitlement.payment.pastDueSince === null ? (
<OpenExternalSplitButton
<Button
type="button"
variant="outline"
size="sm"
aria-disabled={busy || undefined}
link={billingPortalLink}
onClick={() => {
if (!busy) {
onPortal()
}
}}
onClick={busy ? undefined : onPortal}
>
{t('auto.components.billing.manageBilling', 'Manage billing')}
<ExternalLink />
</OpenExternalSplitButton>
</Button>
) : null}
{hasPlan ? (
// Members have no other action here, so it gets the button's chrome (and its alignment).
@@ -1,56 +0,0 @@
import { afterEach, describe, expect, it, vi } from 'vitest'
const toastError = vi.fn()
vi.mock('sonner', () => ({ toast: { error: (...args: unknown[]) => toastError(...args) } }))
import { billingCheckoutLink, billingPortalLink } from './billing-link'
function stubApi(api: Record<string, unknown>): void {
vi.stubGlobal('window', { api: { orcaProfiles: api } })
}
afterEach(() => {
toastError.mockReset()
vi.unstubAllGlobals()
})
describe('billing "Copy link"', () => {
it('returns the minted Portal URL without opening anything', async () => {
const billingPortalLink$ = vi.fn(async () => ({
status: 'ok' as const,
url: 'https://billing.stripe.com/p/session/x'
}))
const billingOpenPortal = vi.fn()
stubApi({ billingPortalLink: billingPortalLink$, billingOpenPortal })
await expect(billingPortalLink()).resolves.toBe('https://billing.stripe.com/p/session/x')
expect(billingOpenPortal).not.toHaveBeenCalled()
expect(toastError).not.toHaveBeenCalled()
})
it('mints Checkout for the same order the button would open', async () => {
const mint = vi.fn(async () => ({
status: 'ok' as const,
url: 'https://checkout.stripe.com/c/pay/cs_1'
}))
stubApi({ billingCheckoutLink: mint })
const args = { plan: 'team', interval: 'year' as const, seats: 5 }
await expect(billingCheckoutLink(args)).resolves.toBe('https://checkout.stripe.com/c/pay/cs_1')
expect(mint).toHaveBeenCalledWith(args)
})
it('says why there is no link with the open path’s copy, then yields null', async () => {
stubApi({ billingPortalLink: async () => ({ status: 'forbidden' }) })
await expect(billingPortalLink()).resolves.toBeNull()
expect(toastError).toHaveBeenCalledWith('Only an owner or admin can manage billing.')
})
it('treats a rejected IPC as a failed billing read', async () => {
stubApi({
billingPortalLink: async () => {
throw new Error('boom')
}
})
await expect(billingPortalLink()).resolves.toBeNull()
expect(toastError).toHaveBeenCalledWith('Couldn’t reach billing. Try again.')
})
})
@@ -1,35 +0,0 @@
// "Copy link" for the Stripe buttons: mints the same Checkout/Portal URL the button opens, without
// opening it. A refusal (signed out, not an admin, no billing account…) is said in a toast with the
// open path's own copy, then null, so the split button adds nothing of its own.
import { toast } from 'sonner'
import { translate } from '@/i18n/i18n'
import type {
OrcaBillingCheckoutArgs,
OrcaBillingLinkResult
} from '../../../../shared/orca-billing'
import { openFailureCopy } from './plan-billing-copy'
async function linkOrToast(mint: () => Promise<OrcaBillingLinkResult>): Promise<string | null> {
const result = await mint().catch((error: unknown): OrcaBillingLinkResult => ({
status: 'failed',
error: String(error)
}))
if (result.status === 'ok') {
return result.url
}
const failure = openFailureCopy(result, translate)
if (failure) {
toast.error(failure)
}
return null
}
/** The Customer Portal URL "Manage billing" / "Update payment method" would open. */
export function billingPortalLink(): Promise<string | null> {
return linkOrToast(() => window.api.orcaProfiles.billingPortalLink())
}
/** The Checkout URL a plan's buy button would open for these args. */
export function billingCheckoutLink(args: OrcaBillingCheckoutArgs): Promise<string | null> {
return linkOrToast(() => window.api.orcaProfiles.billingCheckoutLink(args))
}
@@ -2,7 +2,6 @@ import { useEffect, useId, useRef } from 'react'
import { AlertCircle, Check, ExternalLink, Lock, RotateCcw, XCircle } from 'lucide-react'
import { Button } from '@/components/ui/button'
import { LoadingSpinner } from '@/components/LoadingSpinner'
import { OpenExternalSplitButton } from '@/components/open-external/OpenExternalSplitButton'
import { useIntlLocale, useTranslate } from '@/i18n/use-translate'
import { cn } from '@/lib/class-names'
import { openFailureCopy } from '../plan-billing-copy'
@@ -21,8 +20,6 @@ export type CheckoutPanelProps = {
/** When the order was placed; the renewal date counts from it. */
now: number
onReopen: () => void
/** "Copy link" on Reopen / Try again: a fresh Checkout URL for this order (absent: no chevron). */
reopenLink?: () => Promise<string | null>
onKeepWaiting: () => void
onBack: () => void
/** Where "Contact us" goes when billing can't sell the plan (the plan's supportUrl, else Enterprise's contact). */
@@ -224,22 +221,13 @@ export function CheckoutPanel(props: CheckoutPanelProps): React.JSX.Element {
break
}
const reopenLabel = (
<>
const reopen = (
<Button type="button" onClick={props.onReopen}>
{phase.kind === 'canceled' || phase.kind === 'open-failed' ? <RotateCcw /> : null}
{phase.kind === 'canceled' || phase.kind === 'open-failed'
? t('auto.components.billing.checkout.tryAgain', 'Try again')
: t('auto.components.billing.checkout.reopen', 'Reopen checkout')}
{phase.kind === 'canceled' || phase.kind === 'open-failed' ? null : <ExternalLink />}
</>
)
const reopen = props.reopenLink ? (
<OpenExternalSplitButton link={props.reopenLink} onClick={props.onReopen}>
{reopenLabel}
</OpenExternalSplitButton>
) : (
<Button type="button" onClick={props.onReopen}>
{reopenLabel}
</Button>
)
const back = (
@@ -287,14 +275,14 @@ export function CheckoutPanel(props: CheckoutPanelProps): React.JSX.Element {
phase.result.status === 'plan-unavailable' &&
props.contactUrl &&
props.onContact ? (
<OpenExternalSplitButton
<Button
type="button"
variant="outline"
link={props.contactUrl}
onClick={() => props.contactUrl && props.onContact?.(props.contactUrl)}
>
{t('auto.components.billing.checkout.contactUs', 'Contact us')}
<ExternalLink />
</OpenExternalSplitButton>
</Button>
) : null}
{phase.kind === 'timed-out' ? (
<Button type="button" variant="outline" onClick={props.onKeepWaiting}>
@@ -1,9 +1,5 @@
import { useCallback, useEffect, useRef, useState } from 'react'
import type {
OrcaBillingCheckoutArgs,
OrcaBillingOpenResult
} from '../../../../../shared/orca-billing'
import { billingCheckoutLink } from '../billing-link'
import type { OrcaBillingOpenResult } from '../../../../../shared/orca-billing'
import { getBillingGeneration, recordBillingStatusIfCurrent } from '../billing-summary-store'
import { installWindowVisibilityInterval } from '@/lib/window-activity/window-visibility-interval'
import {
@@ -32,21 +28,6 @@ export type CheckoutFlow = {
/** Restarts the watch window after a timeout. */
keepWaiting: () => void
reset: () => void
/** "Copy link" on the checkout button: mints this order's Checkout URL and starts the watch. */
copyLink: (order: CheckoutOrder) => Promise<string | null>
/** "Copy link" on Reopen: a fresh Checkout URL for the same order. */
copyReopenLink: () => Promise<string | null>
}
/** Joins an open setup session, so Checkout returns to its next step (T2 Compare plans). */
function checkoutArgsFor(order: CheckoutOrder): OrcaBillingCheckoutArgs {
const setupSessionId = activeCloudSetupSessionId()
return {
plan: order.planId,
interval: order.interval,
seats: order.seats,
...(setupSessionId ? { setupSessionId } : {})
}
}
/**
@@ -65,8 +46,15 @@ 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(checkoutArgsFor(order))
.billingOpenCheckout({
plan: order.planId,
interval: order.interval,
seats: order.seats,
...(setupSessionId ? { setupSessionId } : {})
})
.catch((error: unknown): OrcaBillingOpenResult => ({
status: 'failed',
error: String(error)
@@ -87,17 +75,6 @@ export function useCheckoutFlow({ onPaid }: { onPaid: (seats: number) => void })
})
}, [])
// "Copy link": the same Checkout session, minted but not opened. Paying from the pasted link
// (another browser profile) is watched exactly like an opened Checkout.
const copyLink = useCallback(async (order: CheckoutOrder): Promise<string | null> => {
const url = await billingCheckoutLink(checkoutArgsFor(order))
if (url) {
++runId.current
setPhase(nextPhaseAfterOpen(order, { status: 'opened' }, Date.now()))
}
return url
}, [])
const reset = useCallback(() => {
runId.current++
setPhase({ kind: 'idle' })
@@ -206,10 +183,5 @@ export function useCheckoutFlow({ onPaid }: { onPaid: (seats: number) => void })
}
}, [order])
const copyReopenLink = useCallback(
(): Promise<string | null> => (order ? copyLink(order) : Promise.resolve(null)),
[order, copyLink]
)
return { phase, start, reopen, keepWaiting, reset, copyLink, copyReopenLink }
return { phase, start, reopen, keepWaiting, reset }
}
@@ -1,5 +1,5 @@
import { Building2, ExternalLink } from 'lucide-react'
import { OpenExternalSplitButton } from '@/components/open-external/OpenExternalSplitButton'
import { Button } from '@/components/ui/button'
import { useIntlLocale, useTranslate } from '@/i18n/use-translate'
import { PlanCardShell } from './PlanCardShell'
import { planFeatureLines } from './plan-feature-copy'
@@ -46,16 +46,15 @@ export function EnterprisePlanCard({
footer={
contactUrl ? (
<>
<OpenExternalSplitButton
<Button
type="button"
variant="outline"
groupClassName="w-full"
className="flex-1"
link={contactUrl}
className="w-full"
onClick={() => onContactSales(contactUrl)}
>
{t('auto.components.billing.plans.contactSales', 'Contact sales')}
<ExternalLink />
</OpenExternalSplitButton>
</Button>
<p className="text-center text-xs text-muted-foreground">
{t(
'auto.components.billing.plans.entHint',
@@ -88,13 +88,6 @@ export function PlansDialogHost(): React.JSX.Element {
setOrderedAt(Date.now())
checkout.start({ planId, interval, seats: count })
}}
checkoutLink={async ({ planId, interval, seats: count }) => {
const url = await checkout.copyLink({ planId, interval, seats: count })
if (url) {
setOrderedAt(Date.now())
}
return url
}}
onManage={() => void openPortal()}
onContactSales={(url) => void window.api.shell.openUrl(url)}
onRetry={() => {
@@ -126,7 +119,6 @@ export function PlansDialogHost(): React.JSX.Element {
}
checkout.reopen()
}}
reopenLink={checkout.copyReopenLink}
contactUrl={plans.state === 'ready' ? planContactUrl(plans.model) : null}
onContact={(url) => void window.api.shell.openUrl(url)}
onKeepWaiting={checkout.keepWaiting}
@@ -49,13 +49,6 @@ describe("plans dialog from billing's catalog", () => {
expect(props.onContactSales).toHaveBeenCalledWith('https://orca.dev/enterprise')
})
it('gives checkout and Contact sales a "Copy link" chevron for the same order', () => {
const checkoutLink = vi.fn(async () => 'https://checkout.stripe.com/c/pay/cs_1')
render(<PlansView {...view({ checkoutLink })} />)
// One chevron on the checkout button, one on Contact sales.
expect(screen.getAllByRole('button', { name: 'More link options' })).toHaveLength(2)
})
it('offers only the intervals Stripe prices: no toggle with one', () => {
render(<PlansView {...view({ catalog: monthlyOnlyCatalogResult })} />)
expect(screen.queryByRole('radiogroup')).toBeNull()
@@ -36,12 +36,6 @@ export type PlansViewProps = {
/** Seats Checkout will bill: org members, or 1 for a personal account. */
seats: number
onCheckout: (args: { planId: string; interval: OrcaBillingInterval; seats: number }) => void
/** "Copy link" on the checkout button: the Checkout URL it would open (absent: no chevron). */
checkoutLink?: (args: {
planId: string
interval: OrcaBillingInterval
seats: number
}) => Promise<string | null>
onManage: () => void
onContactSales: (url: string) => void
onRetry: () => void
@@ -209,11 +203,6 @@ export function PlansView(props: PlansViewProps): React.JSX.Element {
notice={props.notice}
hideManage={paymentIssue}
onCheckout={() => props.onCheckout({ planId: team.planId, interval, seats })}
checkoutLink={
props.checkoutLink
? () => props.checkoutLink!({ planId: team.planId, interval, seats })
: undefined
}
onManage={props.onManage}
/>
{enterprise ? (
@@ -2,8 +2,6 @@ import { ExternalLink, Lock, Users } from 'lucide-react'
import { Badge } from '@/components/ui/badge'
import { Button } from '@/components/ui/button'
import { InlineError } from '@/components/ui/inline-error'
import { OpenExternalSplitButton } from '@/components/open-external/OpenExternalSplitButton'
import { billingPortalLink } from '../billing-link'
import type { PlanBillingNotice } from '../PlanBillingSection'
import { LoadingSpinner } from '@/components/LoadingSpinner'
import { useIntlLocale, useTranslate } from '@/i18n/use-translate'
@@ -24,7 +22,6 @@ export function TeamPlanCard({
notice,
hideManage,
onCheckout,
checkoutLink,
onManage
}: {
team: TeamPlanModel
@@ -37,8 +34,6 @@ export function TeamPlanCard({
/** A payment banner already offers the same Portal action. */
hideManage: boolean
onCheckout: () => void
/** "Copy link": mints the Checkout URL the button opens (absent: a plain button). */
checkoutLink?: () => Promise<string | null>
onManage: () => void
}): React.JSX.Element {
const t = useTranslate()
@@ -131,41 +126,20 @@ export function TeamPlanCard({
</p>
)
} else if (mode === 'choose') {
const checkoutLabel = (
<>
{busy ? <LoadingSpinner /> : null}
{busy
? t('auto.components.billing.plans.waiting', 'Waiting for checkout…')
: t('auto.components.billing.plans.checkout', 'Continue to checkout')}
{busy ? null : <ExternalLink />}
</>
)
footer = (
<>
{checkoutLink ? (
<OpenExternalSplitButton
groupClassName="w-full"
className="flex-1"
aria-disabled={busy || undefined}
link={checkoutLink}
onClick={() => {
if (!busy) {
onCheckout()
}
}}
>
{checkoutLabel}
</OpenExternalSplitButton>
) : (
<Button
type="button"
className="w-full"
aria-disabled={busy || undefined}
onClick={busy ? undefined : onCheckout}
>
{checkoutLabel}
</Button>
)}
<Button
type="button"
className="w-full"
aria-disabled={busy || undefined}
onClick={busy ? undefined : onCheckout}
>
{busy ? <LoadingSpinner /> : null}
{busy
? t('auto.components.billing.plans.waiting', 'Waiting for checkout…')
: t('auto.components.billing.plans.checkout', 'Continue to checkout')}
{busy ? null : <ExternalLink />}
</Button>
{notice?.kind === 'error' ? (
<InlineError title={notice.text} />
) : (
@@ -189,21 +163,16 @@ export function TeamPlanCard({
</p>
) : (
<>
<OpenExternalSplitButton
<Button
type="button"
variant="outline"
groupClassName="w-full"
className="flex-1"
className="w-full"
aria-disabled={busy || undefined}
link={billingPortalLink}
onClick={() => {
if (!busy) {
onManage()
}
}}
onClick={busy ? undefined : onManage}
>
{t('auto.components.billing.manageBilling', 'Manage billing')}
<ExternalLink />
</OpenExternalSplitButton>
</Button>
{notice?.kind === 'error' ? (
<InlineError title={notice.text} />
) : (
@@ -1,3 +1,4 @@
import { useTeamMfaGate } from '@/components/team-mfa/TeamMfaGate'
import { useCallback, useEffect, useRef, useState } from 'react'
import { toast } from 'sonner'
import { Dialog, DialogContent, DialogDescription, DialogTitle } from '@/components/ui/dialog'
@@ -37,6 +38,7 @@ export function TeamPageBody({
const cloud = authStatus?.cloud
const orgId = cloud?.activeOrgId ?? null
const roster = useOrgRoster(orgId)
const mfa = useTeamMfaGate()
const billing = useOrcaBillingStatus(true)
const [userRefreshing, setUserRefreshing] = useState(false)
const [billingBusy, setBillingBusy] = useState(false)
@@ -174,6 +176,7 @@ export function TeamPageBody({
<>
<TeamPageView
org={org}
mfaNotice={mfa.blocked ?? mfa.banner}
viewerUserId={cloud?.userId ?? null}
roster={rosterResult}
billing={billing.result}
@@ -0,0 +1,32 @@
// @vitest-environment happy-dom
import { cleanup, fireEvent, render, screen } from '@testing-library/react'
import { afterEach, expect, it } from 'vitest'
import { TooltipProvider } from '@/components/ui/tooltip'
import { TeamInviteComposer } from './TeamInviteComposer'
afterEach(cleanup)
const RULE = 'Each invite uses a seat once accepted.'
it('says only the seat rule, with no seat counts or prices, however many are entered', () => {
render(<TeamInviteComposer viewerRole="owner" onInvite={async () => ({ failed: [] })} />, {
wrapper: TooltipProvider
})
const input = screen.getByRole('textbox')
const hint = document.getElementById(input.getAttribute('aria-describedby')!)!
expect(hint.textContent).toBe(RULE)
fireEvent.change(input, { target: { value: 'jordan@acme.dev, kim@acme.dev ' } })
expect(hint.textContent).toBe(RULE)
expect(hint.textContent).not.toMatch(/open seat|\$|prorated/)
})
it('still flags invalid entries after the rule', () => {
render(<TeamInviteComposer viewerRole="owner" onInvite={async () => ({ failed: [] })} />, {
wrapper: TooltipProvider
})
const input = screen.getByRole('textbox')
fireEvent.change(input, { target: { value: 'jordan@acme.dev, not-an-email ' } })
const hint = document.getElementById(input.getAttribute('aria-describedby')!)!
expect(hint.textContent).toBe(`${RULE} Skipping 1 invalid entry.`)
})
@@ -10,9 +10,8 @@ import {
} from '@/components/ui/select'
import { LoadingSpinner } from '@/components/LoadingSpinner'
import { SettingsDisabledControlTooltip } from '@/components/settings/form-controls/SettingsDisabledControlTooltip'
import { useIntlLocale, useTranslate } from '@/i18n/use-translate'
import { useTranslate } from '@/i18n/use-translate'
import { cn } from '@/lib/class-names'
import type { OrcaBillingEntitlement } from '../../../../../shared/orca-billing'
import type { OrcaOrgRole } from '../../../../../shared/orca-profiles'
import {
MAX_INVITES_PER_BATCH,
@@ -22,17 +21,11 @@ import {
} from './parse-invite-emails'
import { roleDescription } from './team-copy'
import { assignableRoles, roleLabel } from './team-roles'
import { inviteSeatImpactLine } from './team-invite-impact-copy'
import { inviteSeatImpact } from './team-seat-math'
export type InviteBatchOutcome = { failed: { email: string; message: string }[] }
export type TeamInviteComposerProps = {
viewerRole: OrcaOrgRole
entitlement: OrcaBillingEntitlement | null
members: number
pendingInvites: number
now: number
/** Sends every invite; resolves with the ones that failed so they stay in the field. */
onInvite: (emails: string[], role: OrcaOrgRole) => Promise<InviteBatchOutcome>
inputRef?: React.Ref<HTMLInputElement>
@@ -41,7 +34,6 @@ export type TeamInviteComposerProps = {
/** Multi-email invite field: paste a list, review the chips, pick a role, send. */
export function TeamInviteComposer(props: TeamInviteComposerProps): React.JSX.Element {
const t = useTranslate()
const locale = useIntlLocale()
const id = useId()
const [draft, setDraft] = useState('')
const [candidates, setCandidates] = useState<InviteCandidate[]>([])
@@ -65,19 +57,10 @@ export function TeamInviteComposer(props: TeamInviteComposerProps): React.JSX.El
const pendingDraft = draft.trim()
? mergeInviteCandidates(candidates, splitInviteText(draft))
: candidates
// The button and the seat line both count what Send would send, including a typed,
// unseparated address, so the seat impact always matches the invites about to go out.
// The button counts what Send would send, including a typed, unseparated address.
const valid = pendingDraft.filter((candidate) => candidate.valid)
const committedValid = candidates.filter((candidate) => candidate.valid)
const invalidCount = candidates.length - committedValid.length
const paymentFailed = props.entitlement?.payment.pastDueSince != null
const impact = inviteSeatImpact({
entitlement: props.entitlement,
members: props.members,
pendingInvites: props.pendingInvites,
newInvites: valid.length,
now: props.now
})
const send = async (): Promise<void> => {
const all = commit(draft)
@@ -271,13 +254,8 @@ export function TeamInviteComposer(props: TeamInviteComposerProps): React.JSX.El
</div>
</div>
<p id={hintId} className="text-xs text-muted-foreground text-pretty">
{inviteSeatImpactLine(impact, valid.length, locale, t)}
{paymentFailed && valid.length > 0
? ` ${t(
'auto.components.billing.team.invitePaymentFailed2',
'New seats are charged once the failed payment is fixed.'
)}`
: null}
{/* Only the rule: seat counts and prices live in Plan & billing (Neil, TEAM-DIALOG-2). */}
{t('auto.components.billing.team.inviteSeatRule', 'Each invite uses a seat once accepted.')}
{invalidCount > 0
? ` ${t(
'auto.components.billing.team.skipInvalid',
@@ -67,3 +67,90 @@ it('offers Leave from the ⋯ on your own row only', () => {
// A plain member has nothing to do on someone else's row.
expect(other.querySelector('button[aria-label^="Actions for"]')).toBeNull()
})
function renderList(
listRoster: OrcaOrgMembersRoster,
viewerUserId: string
): ReturnType<typeof render> {
return render(
<TeamMemberList
rows={teamRows(listRoster, viewerUserId)}
viewerRole={listRoster.viewerRole}
rowStates={{}}
canLeave
now={Date.UTC(2026, 10, 18)}
onChangeRole={noop}
onMakeOwner={noop}
onRemove={noop}
onResend={noop}
onRevoke={noop}
onLeave={noop}
/>
)
}
const rosterWithMfa: OrcaOrgMembersRoster = {
...roster,
members: [
{ ...roster.members[0]!, mfa: 'on' },
{ ...roster.members[1]!, mfa: 'pending', mfaDeadline: Date.UTC(2026, 10, 24, 12) }
],
pendingInvites: [{ email: 'alex@acme.dev', role: 'member', createdAt: Date.UTC(2026, 10, 17) }]
}
it.each(['owner', 'admin'] as const)('shows the MFA column to an %s', (viewerRole) => {
const { container } = renderList({ ...rosterWithMfa, viewerRole }, 'u-neil')
const cell = (key: string): Element =>
container.querySelector(`[data-team-row="${key}"] [data-team-mfa]`)!
expect(cell('member:u-neil').textContent).toBe('MFA on')
expect(cell('member:u-grace').textContent).toBe('MFA due Nov 24')
// A small muted badge, not bare text.
expect(cell('member:u-neil').querySelector('[data-slot="badge"]')).not.toBeNull()
// Invites keep an empty cell so the role column stays aligned.
expect(cell('invite:alex@acme.dev').textContent).toBe('')
})
it('hides the MFA column from a plain member, even if a roster carried the status', () => {
const { container } = renderList(
{ ...rosterWithMfa, viewerRole: 'member', canManageMembers: false },
'u-grace'
)
expect(container.querySelector('[data-team-mfa]')).toBeNull()
expect(container.textContent).not.toContain('MFA')
})
it('shows no MFA column when the server sent no status', () => {
const { container } = renderList(roster, 'u-neil')
expect(container.querySelector('[data-team-mfa]')).toBeNull()
})
it('leaves the cell blank, not "off", for a member with no status', () => {
const { container } = renderList(
{
...roster,
members: [{ ...roster.members[0]!, mfa: 'off' }, roster.members[1]!]
},
'u-neil'
)
const cell = (key: string): Element =>
container.querySelector(`[data-team-row="${key}"] [data-team-mfa]`)!
expect(cell('member:u-neil').textContent).toBe('MFA off')
expect(cell('member:u-grace').textContent).toBe('')
})
it('shows no MFA badge for a member who has not signed in yet', () => {
const { container } = renderList(
{
...roster,
members: [
{ ...roster.members[0]!, mfa: 'on' },
{ userId: null, email: 'linus@acme.dev', role: 'member', mfa: 'off' }
]
},
'u-neil'
)
const pending = container.querySelector(
'[data-team-row="member:linus@acme.dev"] [data-team-mfa]'
)!
expect(pending.textContent).toBe('')
})
@@ -29,6 +29,7 @@ import { useIntlLocale, useTranslate } from '@/i18n/use-translate'
import type { OrcaOrgMember, OrcaOrgRole } from '../../../../../shared/orca-profiles'
import { PersonAvatar } from './TeamAvatar'
import { invitedAsCopy, memberStatusLabel, roleDescription } from './team-copy'
import { memberMfaLabel, showMfaColumn } from './team-member-mfa'
import { assignableRoles, roleLabel } from './team-roles'
import type { TeamRow } from './team-roster-rows'
@@ -243,6 +244,7 @@ function RowMenu({
export function TeamMemberList(props: TeamMemberListProps): React.JSX.Element {
const t = useTranslate()
const locale = useIntlLocale()
const mfaColumn = showMfaColumn(props.rows, props.viewerRole)
return (
<ul
className="divide-y divide-border/60 overflow-hidden rounded-lg border border-border"
@@ -314,6 +316,21 @@ export function TeamMemberList(props: TeamMemberListProps): React.JSX.Element {
) : null}
</div>
{state.busy ? <LoadingSpinner className="size-3.5 shrink-0" /> : null}
{mfaColumn ? (
// Rendered for every row, invites included, so the role column stays aligned.
<span
data-team-mfa={row.kind === 'member' ? (row.member.mfa ?? '') : ''}
className="flex w-28 shrink-0"
>
{/* Only for members who have signed in: someone still pending has no account
state yet, so "off" would mislead. */}
{row.kind === 'member' &&
row.status === 'active' &&
memberMfaLabel(row.member, locale, t) ? (
<Badge variant="tag">{memberMfaLabel(row.member, locale, t)}</Badge>
) : null}
</span>
) : null}
{row.kind === 'member' ? (
<RoleControl
row={row}
@@ -128,6 +128,37 @@ export const memberReadOnly = defineFixture({
)
})
// What the server sends an owner or admin: every member carries an MFA status.
const rosterWithMfa: OrcaOrgMembersRoster = {
...roster,
members: [
{ ...roster.members[0]!, mfa: 'on' },
{ ...roster.members[1]!, mfa: 'off' },
{ ...roster.members[2]!, mfa: 'pending', mfaDeadline: NOW + 6 * DAY },
{ ...roster.members[3]!, mfa: 'off' }
]
}
export const ownerSeesMfaColumn = defineFixture({
width,
render: () => <Page roster={{ status: 'ok', roster: rosterWithMfa }} />
})
export const adminSeesMfaColumn = defineFixture({
width,
render: () => (
<Page
viewerUserId="u-ada"
roster={{ status: 'ok', roster: { ...rosterWithMfa, viewerRole: 'admin' } }}
/>
)
})
export const mfaColumnNarrow = defineFixture({
width: 640,
render: () => <Page roster={{ status: 'ok', roster: rosterWithMfa }} />
})
export const rowBusyAndError = defineFixture({
width,
render: () => (
@@ -244,34 +275,13 @@ async function typeInvites(text: string): Promise<void> {
await new Promise((resolve) => setTimeout(resolve, 100))
}
/** Will add seats: 4 paid, 4 members and 2 pending, so both new invites add a seat. */
/** Pasted list: the chips, one invalid entry, and the seat rule (no counts or prices). */
export const invitePasted = defineFixture({
width,
render: () => <Page billing={{ status: 'ok', entitlement: { ...team, seats: 4 } }} />,
interact: () => typeInvites('jordan@acme.dev, kim@acme.dev, not-an-email ')
})
/** Seats free: 8 paid, 6 taken (members plus pending), so one invite adds nothing. */
export const inviteSeatsFree = defineFixture({
width,
render: () => <Page billing={{ status: 'ok', entitlement: { ...team, seats: 8 } }} />,
interact: () => typeInvites('jordan@acme.dev ')
})
/** Billing unknown (disabled in this build, or it failed): the rule without counts or prices. */
export const inviteBillingUnknown = defineFixture({
width,
render: () => <Page billing={{ status: 'unconfigured' }} />,
interact: () => typeInvites('jordan@acme.dev, kim@acme.dev ')
})
/** Billing sent no price: seats are still counted, no price is shown. */
export const inviteNoPrice = defineFixture({
width,
render: () => <Page billing={{ status: 'ok', entitlement: { ...team, offers: null } }} />,
interact: () => typeInvites('jordan@acme.dev, kim@acme.dev ')
})
/** Short roster so the Enterprise row sits inside the frame. */
export const ssoRow = defineFixture({
width,
@@ -0,0 +1,63 @@
// @vitest-environment happy-dom
import { cleanup, render, screen } from '@testing-library/react'
import { afterEach, expect, it } from 'vitest'
import { TooltipProvider } from '@/components/ui/tooltip'
import type { OrcaOrgMembersRoster } from '../../../../../shared/orca-profiles'
import { sampleTeam } from '../plan-billing-fixtures'
import { TeamPageView, type TeamPageViewProps } from './TeamPageView'
afterEach(cleanup)
const roster: OrcaOrgMembersRoster = {
viewerRole: 'owner',
canManageMembers: true,
members: [
{ userId: 'u-neil', email: 'neil@acme.dev', displayName: 'Neil Parker', role: 'owner' },
{ userId: 'u-ada', email: 'ada@acme.dev', displayName: 'Ada Lovelace', role: 'admin' }
],
pendingInvites: [{ email: 'sam@acme.dev', role: 'member', createdAt: 0 }]
}
const noop = (): void => {}
const props: TeamPageViewProps = {
org: { orgId: 'org-acme', name: 'Acme Engineering' },
viewerUserId: 'u-neil',
roster: { status: 'ok', roster },
billing: { status: 'ok', entitlement: { ...sampleTeam, canManageBilling: true } },
arrival: null,
rowStates: {},
refreshing: false,
billingBusy: false,
now: 0,
create: {
organizations: [],
creating: false,
error: null,
unavailable: false,
switchingOrgId: null
},
onCreateTeam: noop,
onSwitchOrg: noop,
onRefresh: noop,
onInvite: async () => ({ failed: [] }),
onChangeRole: noop,
onMakeOwner: noop,
onRemove: noop,
onResend: noop,
onRevoke: noop,
onLeave: noop,
onSeePlans: noop,
onManageBilling: noop,
onCreateWorkspace: noop,
onDismissArrival: noop
}
it('keeps the header to the name and counts: no role sentence, no Plan & billing button', () => {
render(<TeamPageView {...props} />, { wrapper: TooltipProvider })
const header = document.querySelector('header')!
expect(header.textContent).toContain('2 members · 1 invited')
expect(header.textContent).not.toMatch(/You’re an|Plan & billing/)
expect(header.querySelector('button')).toBeNull()
// Seat counts and prices live only in Plan & billing.
expect(screen.queryByText(/open seat/)).toBeNull()
})
@@ -1,5 +1,5 @@
import { useEffect, useRef } from 'react'
import { CreditCard, RefreshCw } from 'lucide-react'
import { RefreshCw } from 'lucide-react'
import { Button } from '@/components/ui/button'
import { InlineError } from '@/components/ui/inline-error'
import { Skeleton } from '@/components/ui/skeleton'
@@ -26,6 +26,8 @@ import type { TeamPageArrival } from './team-page-store'
export type TeamPageViewProps = {
/** The active team, or null on a personal account. */
org: { orgId: string; name: string } | null
/** The team's MFA requirement for this person: the countdown banner or the setup screen. */
mfaNotice?: React.ReactNode
viewerUserId: string | null
roster: OrcaProfileOrgMembersListResult | null
billing: OrcaBillingStatusResult | null
@@ -114,6 +116,7 @@ export function TeamPageView(props: TeamPageViewProps): React.JSX.Element {
return (
<div className="space-y-6">
{props.mfaNotice ?? null}
<header className="flex items-center gap-3">
<TeamMark name={props.org.name} />
<div className="min-w-0 flex-1">
@@ -141,20 +144,6 @@ export function TeamPageView(props: TeamPageViewProps): React.JSX.Element {
: t('auto.components.billing.team.loadFailedTitle', 'Couldn’t load team')}
</p>
</div>
{!inline && entitlement?.canManageBilling ? (
// Seats, prices and invoices live in Plan & billing; one quiet way there from here.
// mr-6 clears the dialog's close button, which sits in this corner.
<Button
type="button"
variant="ghost"
size="xs"
className="mr-6 shrink-0"
onClick={props.onSeePlans}
>
<CreditCard />
{t('auto.components.billing.team.planBillingLink', 'Plan & billing')}
</Button>
) : null}
</header>
{props.arrival?.kind === 'checkout-success' && entitlement ? (
@@ -213,10 +202,6 @@ export function TeamPageView(props: TeamPageViewProps): React.JSX.Element {
{roster?.canManageMembers ? (
<TeamInviteComposer
viewerRole={viewerRole}
entitlement={entitlement}
members={roster.members.length}
pendingInvites={roster.pendingInvites.length}
now={props.now}
onInvite={props.onInvite}
inputRef={inviteInput}
/>
@@ -1,96 +0,0 @@
import { describe, expect, it } from 'vitest'
import type { OrcaBillingEntitlement } from '../../../../../shared/orca-billing'
import type { Translate } from '@/i18n/use-translate'
import { sampleTeam } from '../plan-billing-fixtures'
import { formatCents } from '../plans/plans-pricing'
import { inviteSeatImpactLine } from './team-invite-impact-copy'
import { inviteSeatImpact } from './team-seat-math'
const DAY = 86_400_000
// Mirrors i18next's `_one` plural pick so both forms are checked.
const t: Translate = (_key, fallback, options) => {
const one = options?.count === 1 ? options.defaultValue_one : undefined
const text = typeof one === 'string' ? one : fallback
return text.replace(/\{\{(\w+)\}\}/g, (_, name: string) => String(options?.[name] ?? ''))
}
function team(overrides: Partial<OrcaBillingEntitlement> = {}): OrcaBillingEntitlement {
return {
...sampleTeam,
status: 'active',
interval: 'month',
seats: 3,
seatChange: null,
cancelAtPeriodEnd: false,
period: { start: 0, end: 30 * DAY },
...overrides
}
}
function line(
entitlement: OrcaBillingEntitlement | null,
counts: { members: number; pendingInvites: number; newInvites: number }
): string {
const impact = inviteSeatImpact({ entitlement, ...counts, now: 0 })
return inviteSeatImpactLine(impact, counts.newInvites, 'en-US', t)
}
const monthly = sampleTeam.offers?.team.monthlyPriceCentsPerSeat ?? 0
describe('invite seat impact line', () => {
it('says how many seats are open before anything is typed', () => {
expect(line(team({ seats: 5 }), { members: 2, pendingInvites: 1, newInvites: 0 })).toBe(
'Each invite uses a seat once accepted. You have 2 open seats.'
)
expect(line(team({ seats: 3 }), { members: 3, pendingInvites: 0, newInvites: 0 })).toBe(
'Each invite uses a seat once accepted. You have no open seats.'
)
})
it('adds nothing while the invites fit in open seats', () => {
expect(line(team({ seats: 4 }), { members: 3, pendingInvites: 0, newInvites: 1 })).toBe(
'Each invite uses a seat once accepted. You have 1 open seat, so no seats will be added.'
)
})
it('prices the added seats from billing, per period, prorated', () => {
const total = formatCents(2 * monthly, 'en-US')
expect(line(team({ seats: 3 }), { members: 3, pendingInvites: 0, newInvites: 2 })).toBe(
`Each invite uses a seat once accepted. You have no open seats, so 2 more seats (${total}/mo, prorated) will be added.`
)
})
it('counts open seats first, then pluralizes the added ones apart', () => {
const one = formatCents(monthly, 'en-US')
expect(line(team({ seats: 4 }), { members: 3, pendingInvites: 0, newInvites: 2 })).toBe(
`Each invite uses a seat once accepted. You have 1 open seat, so 1 more seat (${one}/mo, prorated) will be added.`
)
})
it('names the yearly price on annual plans', () => {
expect(
line(team({ seats: 1, interval: 'year' }), { members: 1, pendingInvites: 0, newInvites: 1 })
).toMatch(/\/yr, prorated\) will be added\.$/)
})
it('never shows a price billing did not send', () => {
expect(
line(team({ seats: 3, offers: null }), { members: 3, pendingInvites: 0, newInvites: 2 })
).toBe(
'Each invite uses a seat once accepted. You have no open seats, so 2 more seats will be added, prorated.'
)
})
it('keeps to the rule when billing is off or unreachable', () => {
expect(line(null, { members: 3, pendingInvites: 0, newInvites: 2 })).toBe(
'Each invite uses a seat once accepted.'
)
})
it('says invites are free before the team has a plan', () => {
expect(
line(team({ plan: null, status: 'none' }), { members: 1, pendingInvites: 0, newInvites: 1 })
).toBe('Invites are free. Seats are billed once your team picks a plan.')
})
})
@@ -1,86 +0,0 @@
// The one line under "Invite teammates" that says what the invites do to seats. Billing's own
// numbers only (ENTITLEMENTS-C): no price is shown when billing didn't send one.
import type { Translate } from '@/i18n/use-translate'
import { formatCents } from '../plans/plans-pricing'
import type { InviteSeatImpact } from './team-seat-math'
/** "You have N open seats", its own key so the seat count and the added count pluralize apart. */
function openSeatsClause(open: number, t: Translate): string {
return open === 0
? t('auto.components.billing.team.openSeatsNone', 'You have no open seats')
: t('auto.components.billing.team.openSeatsClause', 'You have {{count}} open seats', {
count: open,
defaultValue_one: 'You have {{count}} open seat'
})
}
export function inviteSeatImpactLine(
impact: InviteSeatImpact,
invites: number,
locale: string,
t: Translate
): string {
switch (impact.kind) {
case 'unknown':
return t(
'auto.components.billing.team.inviteSeatUnknown',
'Each invite uses a seat once accepted.'
)
case 'no-plan':
return t(
'auto.components.billing.team.inviteNoPlan',
'Invites are free. Seats are billed once your team picks a plan.'
)
case 'covered':
return invites === 0
? t(
'auto.components.billing.team.inviteSeatOpen',
'Each invite uses a seat once accepted. {{openSeats}}.',
{
openSeats: openSeatsClause(impact.freeSeats, t)
}
)
: t(
'auto.components.billing.team.inviteSeatCovered',
'Each invite uses a seat once accepted. {{openSeats}}, so no seats will be added.',
{ openSeats: openSeatsClause(impact.freeSeats, t) }
)
case 'adds-seats-unpriced':
return t(
'auto.components.billing.team.inviteSeatAddsUnpriced',
'Each invite uses a seat once accepted. {{openSeats}}, so {{count}} more seats will be added, prorated.',
{
openSeats: openSeatsClause(impact.freeSeats, t),
count: impact.addedSeats,
defaultValue_one:
'Each invite uses a seat once accepted. {{openSeats}}, so {{count}} more seat will be added, prorated.'
}
)
case 'adds-seats': {
const price = formatCents(impact.addedSeats * impact.perSeatPeriodCents, locale)
return impact.interval === 'year'
? t(
'auto.components.billing.team.inviteSeatAddsYear',
'Each invite uses a seat once accepted. {{openSeats}}, so {{count}} more seats ({{price}}/yr, prorated) will be added.',
{
openSeats: openSeatsClause(impact.freeSeats, t),
count: impact.addedSeats,
price,
defaultValue_one:
'Each invite uses a seat once accepted. {{openSeats}}, so {{count}} more seat ({{price}}/yr, prorated) will be added.'
}
)
: t(
'auto.components.billing.team.inviteSeatAddsMonth',
'Each invite uses a seat once accepted. {{openSeats}}, so {{count}} more seats ({{price}}/mo, prorated) will be added.',
{
openSeats: openSeatsClause(impact.freeSeats, t),
count: impact.addedSeats,
price,
defaultValue_one:
'Each invite uses a seat once accepted. {{openSeats}}, so {{count}} more seat ({{price}}/mo, prorated) will be added.'
}
)
}
}
}
@@ -0,0 +1,40 @@
// The MFA column of the team list: who sees it and what each cell says. Pure, so the view and its
// tests share it.
import type { Translate } from '@/i18n/use-translate'
import type { OrcaOrgMember, OrcaOrgRole } from '../../../../../shared/orca-profiles'
import type { TeamRow } from './team-roster-rows'
/**
* Owners and admins only. The server already leaves the status out for everyone else; the role
* check keeps the column hidden even if a roster carrying it ever reached a member's desktop.
*/
export function showMfaColumn(rows: readonly TeamRow[], viewerRole: OrcaOrgRole): boolean {
return (
(viewerRole === 'owner' || viewerRole === 'admin') &&
rows.some((row) => row.kind === 'member' && row.member.mfa !== undefined)
)
}
/** Null when the provider said nothing about this member: shown as blank, never as "off". */
export function memberMfaLabel(
member: Pick<OrcaOrgMember, 'mfa' | 'mfaDeadline'>,
locale: string,
t: Translate
): string | null {
switch (member.mfa) {
case 'on':
return t('auto.components.billing.team.mfaOn', 'MFA on')
case 'off':
return t('auto.components.billing.team.mfaOff', 'MFA off')
case 'pending':
return member.mfaDeadline === undefined
? t('auto.components.billing.team.mfaPending', 'MFA pending')
: t('auto.components.billing.team.mfaPendingBy', 'MFA due {{value0}}', {
value0: new Intl.DateTimeFormat(locale, { month: 'short', day: 'numeric' }).format(
member.mfaDeadline
)
})
case undefined:
return null
}
}
@@ -1,17 +1,9 @@
import { describe, expect, it } from 'vitest'
import type { OrcaBillingEntitlement } from '../../../../../shared/orca-billing'
import { sampleTeam as activeTeamEntitlement } from '../plan-billing-fixtures'
import { inviteSeatImpact, nextInvoiceEstimate, proratedSeatCents } from './team-seat-math'
import { nextInvoiceEstimate } from './team-seat-math'
const DAY = 86_400_000
const noPlanEntitlement: OrcaBillingEntitlement = {
...activeTeamEntitlement,
plan: null,
planLabel: null,
status: 'none',
interval: null,
period: null
}
function team(overrides: Partial<OrcaBillingEntitlement> = {}): OrcaBillingEntitlement {
return {
@@ -25,73 +17,6 @@ function team(overrides: Partial<OrcaBillingEntitlement> = {}): OrcaBillingEntit
}
}
describe('proratedSeatCents', () => {
it('charges the remaining share of the period', () => {
const pricing = { interval: 'month' as const, perSeatPeriodCents: 5000 }
expect(proratedSeatCents(pricing, { start: 0, end: 30 * DAY }, 15 * DAY)).toBe(2500)
expect(proratedSeatCents(pricing, { start: 0, end: 30 * DAY }, 31 * DAY)).toBe(0)
expect(proratedSeatCents(pricing, { start: 0, end: 30 * DAY }, -DAY)).toBe(5000)
})
})
describe('inviteSeatImpact', () => {
it('reports no plan when unsubscribed', () => {
expect(
inviteSeatImpact({
entitlement: noPlanEntitlement,
members: 1,
pendingInvites: 0,
newInvites: 2,
now: 0
})
).toEqual({ kind: 'no-plan' })
})
it('uses seats already paid this period first (peak seats)', () => {
// 3 paid, 1 member: two free seats, so two invites cost nothing.
expect(
inviteSeatImpact({
entitlement: team(),
members: 1,
pendingInvites: 0,
newInvites: 2,
now: 0
})
).toEqual({ kind: 'covered', freeSeats: 2 })
})
it('counts pending invites against free seats before new ones', () => {
const impact = inviteSeatImpact({
entitlement: team(),
members: 2,
pendingInvites: 1,
newInvites: 2,
now: 15 * DAY
})
expect(impact).toMatchObject({
kind: 'adds-seats',
addedSeats: 2,
coveredSeats: 0,
proratedCentsEach: 2500
})
})
})
describe('inviteSeatImpact without prices', () => {
it('still says seats are added (never "covered") when pricing is unknown', () => {
const unpriced = team({ offers: null })
expect(
inviteSeatImpact({
entitlement: unpriced,
members: 3,
pendingInvites: 0,
newInvites: 2,
now: 0
})
).toEqual({ kind: 'adds-seats-unpriced', addedSeats: 2, freeSeats: 0 })
})
})
describe('nextInvoiceEstimate', () => {
it('bills the renewal seat count, not the period peak', () => {
const estimate = nextInvoiceEstimate(
@@ -1,7 +1,6 @@
// Seat money shown on the Team page. Display estimates only: Stripe computes the real invoice.
// Mirrors the billing design: seats billed = the period's peak membership; a member who joins
// above the paid peak is charged now, prorated; removals only lower seats at renewal; pending
// invites cost nothing until accepted.
// Seat money shown in Plan & billing. Display estimates only: Stripe computes the real invoice.
// Mirrors the billing design: seats billed = the period's peak membership; removals only lower
// seats at renewal.
import type {
OrcaBillingEntitlement,
OrcaBillingInterval
@@ -33,80 +32,6 @@ export function isActivePlan(entitlement: OrcaBillingEntitlement | null): boolea
)
}
/** One seat for the rest of the current period, rounded to the cent like Stripe's proration. */
export function proratedSeatCents(
pricing: SeatPricing,
period: { start: number; end: number },
now: number
): number {
const length = period.end - period.start
if (length <= 0) {
return pricing.perSeatPeriodCents
}
const remaining = Math.min(Math.max(period.end - now, 0), length)
return Math.round((pricing.perSeatPeriodCents * remaining) / length)
}
export type InviteSeatImpact =
/** Billing didn't answer (disabled in this build, signed out or failed): no seat facts to show. */
| { kind: 'unknown' }
| { kind: 'no-plan' }
/** Every new invite fits in seats already paid this period. */
| { kind: 'covered'; freeSeats: number }
/** Seats will be added but the price or period isn't known (older billing service). */
| { kind: 'adds-seats-unpriced'; addedSeats: number; freeSeats: number }
| {
kind: 'adds-seats'
/** Paid seats not taken by a member or a pending invite. */
freeSeats: number
/** How many of the new invites would add a seat when accepted. */
addedSeats: number
/** Seats already paid but unused that the first acceptances take for free. */
coveredSeats: number
proratedCentsEach: number
perSeatPeriodCents: number
interval: OrcaBillingInterval
}
/**
* What inviting `newInvites` people costs if they all accept now. Pending invites are assumed to
* accept first (conservative: never promises a free seat that an earlier invite will take).
*/
export function inviteSeatImpact(args: {
entitlement: OrcaBillingEntitlement | null
members: number
pendingInvites: number
newInvites: number
now: number
}): InviteSeatImpact {
const { entitlement } = args
if (!entitlement) {
return { kind: 'unknown' }
}
if (!isActivePlan(entitlement)) {
return { kind: 'no-plan' }
}
const pricing = seatPricing(entitlement)
const paidSeats = Math.max(entitlement.seats, 1)
const freeSeats = Math.max(0, paidSeats - args.members - args.pendingInvites)
const addedSeats = Math.max(0, args.newInvites - freeSeats)
if (addedSeats === 0) {
return { kind: 'covered', freeSeats }
}
if (!pricing || !entitlement.period) {
return { kind: 'adds-seats-unpriced', addedSeats, freeSeats }
}
return {
kind: 'adds-seats',
freeSeats,
addedSeats,
coveredSeats: Math.min(freeSeats, args.newInvites),
proratedCentsEach: proratedSeatCents(pricing, entitlement.period, args.now),
perSeatPeriodCents: pricing.perSeatPeriodCents,
interval: pricing.interval
}
}
export type NextInvoiceEstimate = {
seats: number
amountCents: number
@@ -6,6 +6,7 @@ import { InlineError } from '@/components/ui/inline-error'
import { Skeleton } from '@/components/ui/skeleton'
import { useTranslate } from '@/i18n/use-translate'
import { SignInAgainNotice } from '@/components/orca-cloud/SignInAgainButton'
import { TeamMfaRefused } from '@/components/team-mfa/TeamMfaAppBanner'
import { describeInlineError } from './cloud-workspace-errors'
import { openCloudWorkspacePicker } from './cloud-workspace-picker-store'
@@ -24,6 +25,16 @@ export function ErrorState({
onSignIn: () => void
}): React.JSX.Element {
const t = useTranslate()
if (reason === 'mfa_required') {
// The team's MFA policy refused this, so neither signing in again nor retrying helps: show
// the setup screen, and under it the plain sentence in case the policy could not be read.
return (
<>
<TeamMfaRefused />
<InlineError className="m-1" tone="neutral" title={describeInlineError(error, reason, t)} />
</>
)
}
if (error === 'unauthorized') {
return <SignInAgainNotice className="m-1" onSignIn={onSignIn} />
}
@@ -29,12 +29,23 @@ export function isUnknownServerFailure(error: string, status?: number): boolean
return status !== undefined && status >= 500 && !DESCRIBED_CODES.has(error)
}
/** The team's MFA policy refused the request: not a session problem, so never "sign in again". */
export function mfaRequiredMessage(t: Translate = translate): string {
return t(
'auto.components.teamMfa.requiredInline',
'Your team requires two-factor authentication. Set it up in Settings, Account to use its cloud workspaces.'
)
}
export function describeError(
error: string,
reason?: string,
t: Translate = translate,
owner?: CloudWorkspaceSeatOwner
): string {
if (reason === 'mfa_required') {
return mfaRequiredMessage(t)
}
if (error === 'not_found') {
return t(
'auto.components.cloudWorkspaces.errorNotFound',
@@ -133,6 +144,9 @@ export function describeInlineError(
reason?: string,
t: Translate = translate
): string {
if (reason === 'mfa_required') {
return mfaRequiredMessage(t)
}
if (error === 'unauthorized') {
return signInAgainMessage(t)
}
@@ -0,0 +1,68 @@
// A cloud workspace's share link: the org slug + W-number link when known, else the sandbox-id form.
import { toast } from 'sonner'
import { translate } from '@/i18n/i18n'
import { cloudWorkspaceShareLink } from '../../../../shared/cloud-workspaces/cloud-workspaces-wire'
import { cloudWorkspaceIdentity, rememberCloudWorkspaces } from './cloud-workspace-identity'
// How long Copy link waits on the control plane before settling for the sandbox-id link.
const LINK_LOOKUP_MS = 3_000
async function lookUpLink(id: string): Promise<string | null> {
let timer: ReturnType<typeof setTimeout> | undefined
try {
const fetched = await Promise.race([
window.api.cloudWorkspaces.get(id),
new Promise<null>((resolve) => {
timer = setTimeout(() => resolve(null), LINK_LOOKUP_MS)
})
])
if (!fetched?.ok) {
return null
}
rememberCloudWorkspaces([fetched.value])
return fetched.value.link ?? null
} catch {
return null
} finally {
clearTimeout(timer)
}
}
/**
* The org slug + W-number link when the control plane gave one, else the sandbox id form, which
* opens for anyone with access. Never rejects: a device that didn't create the workspace (paired,
* offline, signed out) still gets a working link.
*/
export async function shareLinkFor(id: string, chatId?: string | null): Promise<string> {
const link = cloudWorkspaceIdentity(id)?.link ?? (await lookUpLink(id))
return cloudWorkspaceShareLink({ id, ...(link ? { link } : {}) }, chatId)
}
export async function copyCloudWorkspaceLink(
id: string,
chatId?: string | null,
options: { quiet?: boolean } = {}
): Promise<boolean> {
const link = await shareLinkFor(id, chatId)
try {
// Why: main-process clipboard, like every other renderer copy. navigator.clipboard needs a
// focused document with live user activation; after the link lookup (or from the menu or a
// shortcut) Electron rejects it with "Document is not focused".
await window.api.ui.writeClipboardText(link)
} catch (error) {
console.warn('[cloud-workspaces] copy link failed', error)
toast.error(
translate('auto.components.cloudWorkspaces.copyFailed', "Couldn't copy the link. Try again.")
)
return false
}
if (options.quiet) {
return true
}
toast.success(
chatId
? translate('auto.components.cloudWorkspaces.chatLinkCopied', 'Chat link copied')
: translate('auto.components.cloudWorkspaces.workspaceLinkCopied', 'Workspace link copied')
)
return true
}
@@ -11,8 +11,6 @@ import { activateAndRevealWorktree } from '@/lib/workspace/activation/worktree-a
import { refreshRuntimeProjectWorktreesAndLineage } from '@/hooks/runtime-project-refresh-scheduler'
import { RuntimeRpcCallError, unwrapRuntimeRpcResult } from '@/runtime/rpc/calls/runtime-rpc-result'
import type { CloudWorkspace } from '../../../../shared/cloud-workspaces/cloud-workspaces-wire'
import { cloudWorkspaceShareLink } from '../../../../shared/cloud-workspaces/cloud-workspaces-wire'
import { cloudWorkspaceIdentity, rememberCloudWorkspaces } from './cloud-workspace-identity'
import {
getWorktreeExecutionHostId,
toRuntimeExecutionHostId
@@ -66,7 +64,20 @@ function isPairingRejected(error: unknown): boolean {
return error instanceof Error && /\b(unauthori[sz]ed|device_revoked)\b/i.test(error.message)
}
async function connectAndReveal(environmentId: string, name: string): Promise<OpenOutcome> {
export type OpenCloudWorkspaceOptions = {
/**
* The server this open connects to, before any of its rows load. A GitHub-only create's sheet
* hides that server's rows until it hands off to them, so its pending row never doubles up.
*/
onHost?: (hostId: string) => void
}
async function connectAndReveal(
environmentId: string,
name: string,
options: OpenCloudWorkspaceOptions = {}
): Promise<OpenOutcome> {
options.onHost?.(toRuntimeExecutionHostId(environmentId))
const environments = await window.api.runtimeEnvironments.list()
useAppStore.getState().setRuntimeEnvironments(environments)
const environment = environments.find((e) => e.id === environmentId)
@@ -147,7 +158,11 @@ async function wakeIfAsleep(workspace: CloudWorkspace): Promise<OpenOutcome | nu
}
}
async function pairAndReveal(workspace: CloudWorkspace, name: string): Promise<OpenOutcome> {
async function pairAndReveal(
workspace: CloudWorkspace,
name: string,
options: OpenCloudWorkspaceOptions
): Promise<OpenOutcome> {
const api = window.api.cloudWorkspaces
const binding = (await api.environmentBindings())[workspace.id]
if (binding) {
@@ -161,7 +176,7 @@ async function pairAndReveal(workspace: CloudWorkspace, name: string): Promise<O
return refused
}
try {
return await connectAndReveal(binding.environmentId, name)
return await connectAndReveal(binding.environmentId, name, options)
} catch (error) {
// Only a rejected pairing is fixed by pairing again; anything else is surfaced as is.
if (!isPairingRejected(error)) {
@@ -213,10 +228,13 @@ async function pairAndReveal(workspace: CloudWorkspace, name: string): Promise<O
}
// Messages to this workspace now carry the sender line if it is shared with the team.
void refreshCloudMessageSenders().catch(() => undefined)
return await connectAndReveal(added.environment.id, name)
return await connectAndReveal(added.environment.id, name, options)
}
async function openOnce(workspace: CloudWorkspace): Promise<OpenOutcome> {
async function openOnce(
workspace: CloudWorkspace,
options: OpenCloudWorkspaceOptions
): Promise<OpenOutcome> {
const name = cloudWorkspaceTitle(workspace)
try {
if (workspace.access === 'owner') {
@@ -244,7 +262,7 @@ async function openOnce(workspace: CloudWorkspace): Promise<OpenOutcome> {
)
}
}
return await pairAndReveal(workspace, name)
return await pairAndReveal(workspace, name, options)
} catch (error) {
// Raw transport/RPC messages are not user copy; keep them for diagnostics only.
console.warn('[cloud-workspaces] open failed', error)
@@ -262,75 +280,18 @@ async function openOnce(workspace: CloudWorkspace): Promise<OpenOutcome> {
// instead of minting parallel grants.
const opening = new Map<string, Promise<OpenOutcome>>()
export function openCloudWorkspace(workspace: CloudWorkspace): Promise<OpenOutcome> {
export function openCloudWorkspace(
workspace: CloudWorkspace,
options: OpenCloudWorkspaceOptions = {}
): Promise<OpenOutcome> {
const existing = opening.get(workspace.id)
if (existing) {
return existing
}
const attempt = openOnce(workspace).finally(() => opening.delete(workspace.id))
const attempt = openOnce(workspace, options).finally(() => opening.delete(workspace.id))
opening.set(workspace.id, attempt)
return attempt
}
// How long Copy link waits on the control plane before settling for the sandbox-id link.
const LINK_LOOKUP_MS = 3_000
async function lookUpLink(id: string): Promise<string | null> {
let timer: ReturnType<typeof setTimeout> | undefined
try {
const fetched = await Promise.race([
window.api.cloudWorkspaces.get(id),
new Promise<null>((resolve) => {
timer = setTimeout(() => resolve(null), LINK_LOOKUP_MS)
})
])
if (!fetched?.ok) {
return null
}
rememberCloudWorkspaces([fetched.value])
return fetched.value.link ?? null
} catch {
return null
} finally {
clearTimeout(timer)
}
}
/**
* The org slug + W-number link when the control plane gave one, else the sandbox id form, which
* opens for anyone with access. Never rejects: a device that didn't create the workspace (paired,
* offline, signed out) still gets a working link.
*/
export async function shareLinkFor(id: string, chatId?: string | null): Promise<string> {
const link = cloudWorkspaceIdentity(id)?.link ?? (await lookUpLink(id))
return cloudWorkspaceShareLink({ id, ...(link ? { link } : {}) }, chatId)
}
export async function copyCloudWorkspaceLink(
id: string,
chatId?: string | null,
options: { quiet?: boolean } = {}
): Promise<boolean> {
const link = await shareLinkFor(id, chatId)
try {
// Why: main-process clipboard, like every other renderer copy. navigator.clipboard needs a
// focused document with live user activation; after the link lookup (or from the menu or a
// shortcut) Electron rejects it with "Document is not focused".
await window.api.ui.writeClipboardText(link)
} catch (error) {
console.warn('[cloud-workspaces] copy link failed', error)
toast.error(
translate('auto.components.cloudWorkspaces.copyFailed', "Couldn't copy the link. Try again.")
)
return false
}
if (options.quiet) {
return true
}
toast.success(
chatId
? translate('auto.components.cloudWorkspaces.chatLinkCopied', 'Chat link copied')
: translate('auto.components.cloudWorkspaces.workspaceLinkCopied', 'Workspace link copied')
)
return true
}
// Copy link lives beside it; re-exported so callers keep one import.
export { copyCloudWorkspaceLink, shareLinkFor } from './cloud-workspace-share-link'
@@ -0,0 +1,15 @@
import { toast } from 'sonner'
import type { Translate } from '@/i18n/use-translate'
/**
* "Shared with your team", with the one thing that changes for the owner (SEC-5): their personal
* secrets stop being injected once teammates can open the workspace.
*/
export function toastSharedWithTeam(t: Translate): void {
toast.success(t('auto.components.cloudWorkspaces.sharedWithYourTeam', 'Shared with your team'), {
description: t(
'auto.components.cloudWorkspaces.sharedPersonalSecretsNote',
'Your personal cloud secrets aren’t used in shared workspaces. Shared and repository secrets still are.'
)
})
}
@@ -21,6 +21,7 @@ import type { RowActions } from './CloudWorkspaceRowMenu'
import { CloudWorkspaceConfirmDialog, type PendingConfirm } from './CloudWorkspaceConfirmDialog'
import { CloudReadSnapshotSheet } from './CloudReadSnapshotSheet'
import { useCloudReadPanel } from './use-cloud-read-panel'
import { toastSharedWithTeam } from './shared-with-team-toast'
/** Names for every member id the rows show, and whether you are a team owner or admin. */
export function useMemberDirectory(
@@ -130,9 +131,7 @@ export function useCloudWorkspaceRowActions({
void refreshCloudMessageSenders().catch(() => undefined)
}
if (change.visibility === 'team') {
toast.success(
t('auto.components.cloudWorkspaces.sharedWithYourTeam', 'Shared with your team')
)
toastSharedWithTeam(t)
} else if (change.visibility === 'private') {
toast.success(
t(
@@ -1,6 +1,8 @@
import { translate } from '@/i18n/i18n'
import { useCloudChatHoldHint } from '../../agent-sign-in-strip/use-cloud-chat-hold-hint'
import { structuredCloudHoldKey } from '@/lib/orca-cloud/cloud-structured-launch-hold'
import { useCloudChatSendBlock } from '../../agent-sign-in-strip/use-cloud-chat-running-strip'
import { structuredAgentSessionPaneKey } from '../../../../../shared/agent-session/view/structured-agent-session-projection'
import { useTranslate, type Translate } from '@/i18n/use-translate'
import {
managedRuntimeInstallCard,
@@ -33,7 +35,10 @@ const RESERVED: NativeChatInstallSlotState = { kind: 'reserved' }
/** Reserve unknown readiness with an editable composer and held sends; missing runtimes show installation, while read failures leave it alone. */
export function useNativeChatInstallSlot(
props: Pick<NativeChatStructuredViewProps, 'target' | 'agent' | 'isVisible' | 'sessionId'>,
props: Pick<
NativeChatStructuredViewProps,
'target' | 'agent' | 'isVisible' | 'sessionId' | 'tabId'
>,
agentLabel: string,
layout: ManagedRuntimeInstallLayout
): {
@@ -49,7 +54,15 @@ export function useNativeChatInstallSlot(
hostProgram
)
// CHAT-BANNERS: an Orca Cloud launch held on the chat's strip has no agent to send to yet.
const cloudHoldHint = useCloudChatHoldHint(structuredCloudHoldKey(props.sessionId), '')
const cloudHoldKey = structuredCloudHoldKey(props.sessionId)
const cloudHoldHint = useCloudChatHoldHint(cloudHoldKey, '')
// While its Orca Cloud account is expired, the chat takes typing but holds Send (draft kept).
const cloudSendBlock = useCloudChatSendBlock({
tabId: props.tabId,
statusKey: structuredAgentSessionPaneKey(props.tabId, props.sessionId),
holdKey: cloudHoldKey,
agent: props.agent
})
const unavailableHint =
cloudHoldHint ??
(slot.kind === 'install'
@@ -57,7 +70,8 @@ export function useNativeChatInstallSlot(
: undefined)
return {
slot,
sendBlockedReason: unavailableHint ?? installSlotSendBlockedReason(slot, agentLabel, t),
sendBlockedReason:
unavailableHint ?? cloudSendBlock ?? installSlotSendBlockedReason(slot, agentLabel, t),
unavailableHint
}
}
@@ -152,6 +152,7 @@ export function nativeChatPaneHeader(
tabId={view.tabId}
paneKey={structuredCloudHoldKey(view.sessionId)}
statusKey={structuredAgentSessionPaneKey(view.tabId, view.sessionId)}
agent={view.agent}
/>
)
const header =
@@ -1,20 +1,12 @@
// PROJ-MENU part 2: "Give Orca Cloud access to more repositories" moves out of the project list into
// the Add project menu, in its own "Orca Cloud" group: "Add a GitHub repository…".
import React from 'react'
import { Github, Link2 } from 'lucide-react'
import { Github } from 'lucide-react'
import { DropdownMenuItem, DropdownMenuSeparator } from '@/components/ui/dropdown-menu'
import { useTranslate } from '@/i18n/use-translate'
import { copyExternalLink } from '@/components/open-external/copy-external-link'
import { gitHubInstallLinkSource } from '@/lib/orca-cloud/github-link-sources'
import type { ProjectComboboxAddProjectMenu } from './ProjectComboboxAddProjectOption'
function FromGitHubItem({
onSelect,
onCopyLink
}: {
onSelect: () => void
onCopyLink: () => void
}): React.JSX.Element {
function FromGitHubItem({ onSelect }: { onSelect: () => void }): React.JSX.Element {
const t = useTranslate()
return (
<>
@@ -33,13 +25,6 @@ function FromGitHubItem({
{t('components.newWorkspace.cloudOnly.addRepositoryMenu', 'Add a GitHub repository…')}
</span>
</DropdownMenuItem>
{/* A menu row can't carry a chevron: the same GitHub page, copied for another browser. */}
<DropdownMenuItem onSelect={onCopyLink}>
<Link2 />
<span className="truncate">
{t('components.newWorkspace.cloudOnly.copyAddRepositoryLink', 'Copy GitHub link')}
</span>
</DropdownMenuItem>
</>
)
}
@@ -60,10 +45,6 @@ export function cloudAddProjectExtraItems(
closeMenus()
onMoreCloudAccess()
}}
onCopyLink={() => {
closeMenus()
void copyExternalLink(gitHubInstallLinkSource())
}}
/>
)
}
@@ -78,7 +78,7 @@ export function useCloudStartSteps({
onGranted: () => grantedRef.current?.(repoNameRef.current),
...(setupSessionId ? { setupSessionId } : {})
})
const { state, access: grant, repoName, owner, loading, openInstall, installLink } = repoAccess
const { state, access: grant, repoName, owner, loading, openInstall } = repoAccess
useEffect(() => {
repoNameRef.current = repoName
}, [repoName])
@@ -120,5 +120,5 @@ export function useCloudStartSteps({
),
[access, agentRow, availability, github, githubOverride, session, state]
)
return { steps, session, openInstall, installLink }
return { steps, session, openInstall }
}
@@ -0,0 +1,102 @@
// @vitest-environment happy-dom
// AUTH-ONLY-COPY-LINK: "Copy link" (the split's chevron) is for sign-in pages only, where people paste
// the URL into an incognito window. Billing, help, support and the GitHub App install keep a plain
// button, and nothing adds a "Copy … link" row next to them.
import { cleanup, render, screen, within } from '@testing-library/react'
import userEvent from '@testing-library/user-event'
import { afterEach, expect, it, vi } from 'vitest'
import { TooltipProvider } from '@/components/ui/tooltip'
import { PaymentIssueNotice } from '@/components/billing/PaymentIssueNotice'
import { sampleTeam } from '@/components/billing/plan-billing-fixtures'
import {
FailureActionRow,
type VmBuildFailureActions
} from '@/components/worktree-creation/VmBuildFailureActions'
import { translate } from '@/i18n/i18n'
import { OpenExternalSplitButton } from './OpenExternalSplitButton'
afterEach(cleanup)
const chevrons = (): number => document.querySelectorAll('[data-open-external-chevron]').length
const actions: VmBuildFailureActions = {
onFixWithAgent: vi.fn(),
onRetry: vi.fn(),
onEditRecipe: vi.fn(),
onOpenAnyway: vi.fn(),
onStartAgain: vi.fn(),
onDismiss: vi.fn(),
onSeePlans: vi.fn(),
onOpenBilling: vi.fn(),
onCreateLocally: vi.fn(),
onSignIn: vi.fn(),
onShowWorkspaces: vi.fn(),
onContactSupport: vi.fn(),
onConnectGitHub: vi.fn(),
onPushToGitHub: vi.fn()
}
function failureRow(kind: 'githubNotConnected' | 'noGithubRemote' | 'snapshotMissing'): void {
render(
<TooltipProvider>
<FailureActionRow
failure={{ kind }}
cloud
vmKept={false}
canFixWithAgent={false}
canManageBilling
signingIn={false}
connectingGitHub={false}
actions={actions}
t={translate}
/>
</TooltipProvider>
)
}
it('keeps the chevron on a sign-in button', () => {
render(
<OpenExternalSplitButton link="https://claude.ai/oauth/authorize" onClick={() => {}}>
Open again
</OpenExternalSplitButton>
)
expect(chevrons()).toBe(1)
})
it('"Update payment method" is a plain button', () => {
render(
<PaymentIssueNotice
entitlement={{
...sampleTeam,
payment: { pastDueSince: 1, graceEndsAt: null, suspendRunning: true }
}}
busy={false}
onUpdatePayment={() => {}}
/>
)
expect(screen.getByRole('button', { name: /Update payment method/ })).toBeTruthy()
expect(chevrons()).toBe(0)
})
it('Connect GitHub (App install) and "How to push to GitHub" are plain buttons', () => {
failureRow('githubNotConnected')
expect(screen.getByRole('button', { name: /Connect GitHub/ })).toBeTruthy()
expect(chevrons()).toBe(0)
cleanup()
failureRow('noGithubRemote')
expect(screen.getByRole('button', { name: /How to push to GitHub/ })).toBeTruthy()
expect(chevrons()).toBe(0)
})
it('"Contact support" has no "Copy support link" row beside it', async () => {
failureRow('snapshotMissing')
const more = screen.queryAllByRole('button').find((b) => b.getAttribute('aria-haspopup'))
expect(more).toBeTruthy()
await userEvent.setup().click(more!)
const menu = await screen.findByRole('menu')
const items = within(menu)
.getAllByRole('menuitem')
.map((item) => item.textContent?.trim())
expect(items.some((label) => label?.includes('Contact support'))).toBe(true)
expect(items.some((label) => /copy/i.test(label ?? ''))).toBe(false)
})
@@ -1,7 +1,6 @@
import React from 'react'
import { ExternalLink } from 'lucide-react'
import { Button } from '@/components/ui/button'
import { OpenExternalSplitButton } from '@/components/open-external/OpenExternalSplitButton'
import { openAppHttpLink } from '@/lib/browser/navigation/app-http-link-open'
import { useTranslate } from '@/i18n/use-translate'
@@ -24,14 +23,10 @@ export function CloudCapabilityOffActions({
{t('cloudSetupPage.capability.tryAgain', 'Try again')}
</Button>
{contactUrl ? (
<OpenExternalSplitButton
variant="outline"
link={contactUrl}
onClick={() => openAppHttpLink(contactUrl)}
>
<Button type="button" variant="outline" onClick={() => openAppHttpLink(contactUrl)}>
{t('cloudSetupPage.capability.contact', 'Contact us')}
<ExternalLink aria-hidden />
</OpenExternalSplitButton>
</Button>
) : null}
</div>
)
@@ -36,8 +36,7 @@ function flow(rows: CloudSetupStep[], teamSwitch = false): CloudSetupFlow {
checkAgain: noop,
contactUrl: null,
reopenBrowser: noop,
reopenLink: null,
installGitHubLink: null
reopenLink: null
}
}
@@ -211,7 +211,7 @@ function StepActions({
</Button>
)
case 'github-install':
return browser(continueLabel, flow.installGitHub, flow.installGitHubLink)
return browser(continueLabel, flow.installGitHub)
case 'start-trial':
return (
<Button type="button" onClick={flow.startTrial} disabled={flow.busy}>
@@ -105,10 +105,11 @@ export type CloudSetupFlow = CloudSetupPageModel & {
/** Where "Contact us" goes when Orca Cloud isn't turned on for the team; null hides it. */
contactUrl: string | null
reopenBrowser: () => void
/** "Copy link" beside Reopen browser: a fresh one-time setup link; null without a session. */
/**
* "Copy link" beside Reopen browser on the sign-in step: a fresh one-time setup link. Null on
* other steps (plan, billing, GitHub App install) and without a session.
*/
reopenLink: ExternalLinkSource | null
/** "Copy link" beside the GitHub step's button: the same install page, minted without opening. */
installGitHubLink: ExternalLinkSource | null
}
export function useCloudSetupFlow(
@@ -135,8 +136,7 @@ export function useCloudSetupFlow(
const {
steps: rowSteps,
session,
openInstall,
installLink
openInstall
} = useCloudStartSteps({
availability,
access,
@@ -318,7 +318,7 @@ export function useCloudSetupFlow(
checkAgain,
contactUrl,
reopenBrowser: () => void reopenCloudSetup(sessionId, continueInBrowser),
reopenLink: cloudSetupLinkSource(sessionId),
installGitHubLink: installLink
// Copy link is for sign-in pages only (pasted into an incognito window or another profile).
reopenLink: signingIn || model.action === 'sign-in' ? cloudSetupLinkSource(sessionId) : null
}
}
@@ -17,8 +17,6 @@ import {
repoSlug,
runCloudSetupScript
} from '@/lib/orca-cloud/cloud-setup-notice-actions'
import { gitHubInstallLinkSource } from '@/lib/orca-cloud/github-link-sources'
import type { ExternalLinkSource } from '@/components/open-external/copy-external-link'
import { recheckCloudFetch } from '@/lib/orca-cloud/cloud-fetch-notice'
import { runVmEnvironmentCheck } from '@/runtime/ephemeral-vm/ephemeral-vm-environment-check'
import { hideCloudToast, showCloudToast, type CloudToastView } from './cloud-toast-stack'
@@ -38,8 +36,6 @@ export type CloudSetupNoticeLine = {
icon: React.ReactNode
run: () => void
pending?: boolean
/** Opens this page in the browser: "Copy link" beside it. */
link?: ExternalLinkSource
} | null
}
@@ -75,8 +71,7 @@ export function cloudSetupNoticeLine(
<GitPullRequestArrow />
),
run: handlers.install,
pending: handlers.installing,
link: gitHubInstallLinkSource({ repoUrl: record.repoUrl })
pending: handlers.installing
}
}
}
@@ -257,8 +252,7 @@ export function cloudSetupNoticesView(
label: line.action.label,
icon: line.action.icon,
onClick: line.action.run,
...(line.action.pending ? { pending: true } : {}),
...(line.action.link ? { link: line.action.link } : {})
...(line.action.pending ? { pending: true } : {})
}
}
: {}),
@@ -12,6 +12,7 @@ import {
} from 'lucide-react'
import { DropdownMenuItem, DropdownMenuSeparator } from '@/components/ui/dropdown-menu'
import { useTranslate } from '@/i18n/use-translate'
import { toastSharedWithTeam } from '@/components/cloud-workspaces/shared-with-team-toast'
import { isCloudSyncAvailable, requestCloudSyncFocus } from '@/lib/orca-cloud/cloud-sync-store'
import {
ConfirmationDialogContext,
@@ -178,14 +179,16 @@ async function setVisibility(
)
return
}
toast.success(
visibility === 'team'
? t('auto.components.cloudWorkspaces.sharedWithYourTeam', 'Shared with your team')
: t(
'auto.components.cloudWorkspaces.nowPrivate',
'Now private. Teammates’ devices were disconnected.'
)
)
if (visibility === 'team') {
toastSharedWithTeam(t)
} else {
toast.success(
t(
'auto.components.cloudWorkspaces.nowPrivate',
'Now private. Teammates’ devices were disconnected.'
)
)
}
reload()
}
@@ -13,8 +13,6 @@ import React, { useSyncExternalStore } from 'react'
import { TriangleAlert, X } from 'lucide-react'
import { toast } from 'sonner'
import { Button } from '@/components/ui/button'
import { OpenExternalSplitButton } from '@/components/open-external/OpenExternalSplitButton'
import type { ExternalLinkSource } from '@/components/open-external/copy-external-link'
import { useTranslate } from '@/i18n/use-translate'
import { cn } from '@/lib/class-names'
import { BANNER_BODY_TEXT, BANNER_TONE } from '@/components/ui/banner-tone'
@@ -29,8 +27,6 @@ export type CloudToastAction = {
primary?: boolean
icon?: React.ReactNode
pending?: boolean
/** The action opens this page in the browser: its chevron offers "Copy link". */
link?: ExternalLinkSource
}
export type CloudToastLine = {
@@ -368,19 +364,7 @@ export function CloudToastCard({
<p className={cn('text-xs', BANNER_BODY_TEXT)}>{line.description}</p>
) : null}
</div>
{line.action?.link ? (
<OpenExternalSplitButton
size="xs"
variant={line.action.primary ? 'default' : 'outline'}
link={line.action.link}
onClick={() => (line.action?.pending ? undefined : line.action?.onClick())}
aria-disabled={line.action.pending || undefined}
aria-busy={line.action.pending || undefined}
>
{line.action.icon}
{line.action.label}
</OpenExternalSplitButton>
) : line.action ? (
{line.action ? (
<Button
type="button"
size="xs"
@@ -0,0 +1,43 @@
import { defineFixture } from '../../../../component-fixtures/component-fixture'
import { AccountMfaRowView } from './AccountMfaRow'
import type { AccountMfaState } from './use-account-mfa'
const width = 760
const noop = (): void => {}
const setupUrl = 'https://cloud.orca.dev/v1/account/security'
/** The row as it sits under the signed-in identity in Settings, Account. */
function row(state: AccountMfaState, frameWidth = width) {
return defineFixture({
width: frameWidth,
render: () => (
<div className="bg-background px-8 py-6">
<AccountMfaRowView state={state} onOpenSetup={noop} />
</div>
)
})
}
/** No second factor yet: why to add one, and Set up in browser (chevron: Copy link). */
export const off = row({ kind: 'known', mfa: 'off', setupUrl })
/** Enrolled: Manage in browser, for a new authenticator or the backup codes. */
export const on = row({ kind: 'known', mfa: 'on', setupUrl })
/** A narrow settings pane: the button wraps under the text. */
export const offNarrow = row({ kind: 'known', mfa: 'off', setupUrl }, 420)
/** The chevron's menu, open on Copy link. */
export const copyLinkMenu = defineFixture({
width,
render: () => (
<div className="bg-background px-8 pt-6 pb-24">
<AccountMfaRowView state={{ kind: 'known', mfa: 'off', setupUrl }} onOpenSetup={noop} />
</div>
),
interact: async (frame) => {
const chevron = frame.querySelector<HTMLButtonElement>('button[aria-haspopup="menu"]')
chevron?.dispatchEvent(new PointerEvent('pointerdown', { bubbles: true, button: 0 }))
await new Promise((resolve) => setTimeout(resolve, 50))
}
})
@@ -0,0 +1,72 @@
import { ShieldCheck } from 'lucide-react'
import { Badge } from '@/components/ui/badge'
import { OpenExternalSplitButton } from '@/components/open-external/OpenExternalSplitButton'
import { useTranslate } from '@/i18n/use-translate'
import { useAccountMfa, type AccountMfaState } from './use-account-mfa'
export type AccountMfaRowViewProps = {
state: AccountMfaState
onOpenSetup: () => void
}
/** One state of the row; renders nothing until the first status read answers. */
export function AccountMfaRowView({
state,
onOpenSetup
}: AccountMfaRowViewProps): React.JSX.Element | null {
const t = useTranslate()
if (state.kind === 'unknown') {
return null
}
const on = state.mfa === 'on'
return (
<div className="flex flex-wrap items-center gap-4 border-t border-border/60 pt-5">
<div className="flex size-11 shrink-0 items-center justify-center rounded-full bg-muted text-foreground">
<ShieldCheck className="size-5" />
</div>
<div className="min-w-0 flex-1 space-y-1">
<div className="flex flex-wrap items-center gap-2">
<p className="text-sm font-medium">
{t('auto.components.settings.orcaAccount.mfa.title', 'Two-factor authentication')}
</p>
<Badge variant="outline" className="text-[11px] text-muted-foreground">
{on
? t('auto.components.settings.orcaAccount.mfa.on', 'On')
: t('auto.components.settings.orcaAccount.mfa.off', 'Off')}
</Badge>
</div>
<p className="text-xs leading-5 text-muted-foreground" aria-live="polite">
{on
? t(
'auto.components.settings.orcaAccount.mfa.onDescription',
'Signing in asks for a code from your authenticator app. Keep your backup codes somewhere safe.'
)
: t(
'auto.components.settings.orcaAccount.mfa.offDescription',
'Add an authenticator app so a stolen password is not enough to sign in. You get backup codes too.'
)}
</p>
</div>
{/* Opens the account page in the browser; the chevron copies that link instead. */}
<OpenExternalSplitButton
variant="outline"
size="sm"
link={state.setupUrl}
onClick={onOpenSetup}
>
{on
? t('auto.components.settings.orcaAccount.mfa.manage', 'Manage in browser')
: t('auto.components.settings.orcaAccount.mfa.setUp', 'Set up in browser')}
</OpenExternalSplitButton>
</div>
)
}
/**
* "Two-factor authentication" under the signed-in identity. Mount it only while signed in to Orca
* Cloud.
*/
export function AccountMfaRow(): React.JSX.Element | null {
const mfa = useAccountMfa()
return <AccountMfaRowView state={mfa.state} onOpenSetup={mfa.openSetup} />
}
@@ -11,6 +11,7 @@ import { useAppStore } from '@/store/index'
import { OrcaProfileSignOutConfirmDialog } from '../../../orca-profiles/OrcaProfileSignOutConfirmDialog'
import { OrcaSignInButton, OrcaSignInWaitNotice } from '../../../OrcaSignInProgress'
import { useOrcaCloudApiAvailable } from '@/hooks/useOrcaCloudApiAvailability'
import { AccountMfaRow } from './AccountMfaRow'
import { GitHubIdentityRow } from './GitHubIdentityRow'
function accountStatusCopy(
@@ -135,6 +136,9 @@ export function OrcaAccountSettingsPane(): React.JSX.Element {
{/* The person's own GitHub for cloud commits; only signed in to Orca Cloud. */}
{connected && cloudAvailable ? <GitHubIdentityRow /> : null}
{/* Their own second factor: status, and a link to the account page that manages it. */}
{connected && cloudAvailable ? <AccountMfaRow /> : null}
{/* JA-16: with Orca Cloud the page is identity + Sign out only; plan, team and agents have
their own entries in the Orca Cloud group right beside it. */}
{cloudAvailable ? null : (
@@ -0,0 +1,89 @@
import { useCallback, useEffect, useState } from 'react'
import { installWindowVisibilityInterval } from '@/lib/window-activity/window-visibility-interval'
import type { OrcaAccountMfa } from '../../../../../../shared/orca-account-mfa'
/** Re-check every few seconds after the browser opened, for at most five minutes. */
export const ACCOUNT_MFA_POLL_MS = 3_000
export const ACCOUNT_MFA_WATCH_MAX_MS = 5 * 60_000
export type AccountMfaState =
/** Not read yet, every read failed, or this deployment has no MFA status: the row is hidden. */
{ kind: 'unknown' } | ({ kind: 'known' } & OrcaAccountMfa)
export type AccountMfa = {
state: AccountMfaState
/** Opens the account's security page in the browser, then watches for the change. */
openSetup: () => void
}
/**
* The signed-in person's own two-factor state (mount only while signed in to Orca Cloud). Read on
* mount and when the window regains focus; polled lightly after the browser was opened, since the
* person enrols there and comes back.
*/
export function useAccountMfa(): AccountMfa {
const [state, setState] = useState<AccountMfaState>({ kind: 'unknown' })
const [watching, setWatching] = useState<'on' | 'off' | null>(null)
const refresh = useCallback(async (): Promise<void> => {
let result: Awaited<ReturnType<typeof window.api.orcaProfiles.accountMfa>> | null
try {
result = (await window.api.orcaProfiles.accountMfa()) ?? null
} catch {
result = null
}
// A failed read keeps what the row shows; the next focus or poll tries again.
if (result?.status === 'ok') {
setState({ kind: 'known', mfa: result.mfa, setupUrl: result.setupUrl })
}
}, [])
useEffect(() => {
void refresh()
const onFocus = (): void => void refresh()
const onVisibility = (): void => {
if (document.visibilityState === 'visible') {
void refresh()
}
}
window.addEventListener('focus', onFocus)
document.addEventListener('visibilitychange', onVisibility)
return () => {
window.removeEventListener('focus', onFocus)
document.removeEventListener('visibilitychange', onVisibility)
}
}, [refresh])
// Stop watching once the state differs from what it was when the browser opened.
const changed = watching !== null && state.kind === 'known' && state.mfa !== watching
useEffect(() => {
if (changed) {
setWatching(null)
}
}, [changed])
useEffect(() => {
if (watching === null) {
return
}
const stopPolling = installWindowVisibilityInterval({
run: () => void refresh(),
intervalMs: ACCOUNT_MFA_POLL_MS
})
const expire = setTimeout(() => setWatching(null), ACCOUNT_MFA_WATCH_MAX_MS)
return () => {
stopPolling()
clearTimeout(expire)
}
}, [watching, refresh])
const openSetup = useCallback((): void => {
if (state.kind !== 'known') {
return
}
void window.api.shell.openUrl(state.setupUrl)
setWatching(state.mfa)
}, [state])
return { state, openSetup }
}
@@ -199,7 +199,7 @@ function list(
initialMode={mode}
initialSaved={options.saved}
onSetUpAgent={noop}
description="Only you get these, in every Orca Cloud workspace you start."
description="Only you get these, in cloud workspaces you haven’t shared. Shared workspaces don’t get them."
/>
</Frame>
)

Some files were not shown because too many files have changed in this diff Show More