diff --git a/src/main/agent-api-keys/agent-api-key-cloud-connection.ts b/src/main/agent-api-keys/agent-api-key-cloud-connection.ts index d9fca3fe2c5..e270a5e7e62 100644 --- a/src/main/agent-api-keys/agent-api-key-cloud-connection.ts +++ b/src/main/agent-api-keys/agent-api-key-cloud-connection.ts @@ -6,7 +6,7 @@ import type { CloudSecretsClient } from '../cloud-secrets/cloud-secrets-client' import { getOrcaCloudAvailability } from '../hosted-sandbox/hosted-sandbox-install' import { getOrcaProfileIndexGeneration } from '../orca-profiles/profile-index-generation' import { ensureActiveOrcaProfile } from '../orca-profiles/profile-index-store' -import type { AgentApiKeyCloudConnection } from './agent-api-key-cloud-sync' +import type { AgentApiKeyCloudLink } from './agent-api-key-cloud-sync' let client: CloudSecretsClient | null = null let recorder: ((agent: TuiAgent, envName: string) => Promise) | null = null @@ -26,15 +26,27 @@ export function setAgentApiKeyCloudClient(next: CloudSecretsClient | null): void client = next } -/** The signed-in Orca account with Orca Cloud, or null: signed out, no capability, or offline. */ -export async function agentApiKeyCloudConnection(): Promise { +/** + * Where this desktop stands with the Orca account. Signed in but `unavailable` means the session + * couldn't be refreshed (offline), not a sign-out: the account is still the profile's. + */ +export async function agentApiKeyCloudLink(): Promise { const current = client const generation = getOrcaProfileIndexGeneration() - if (!current || (await getOrcaCloudAvailability()) !== 'offered') { - return null + if (!current) { + return { kind: 'signed-out' } } + const availability = await getOrcaCloudAvailability() const accountId = ensureActiveOrcaProfile(app.getPath('userData')).profile.cloud?.userId // Every sign-in, sign-out and account or team switch rewrites the profile index. const isCurrent = (): boolean => getOrcaProfileIndexGeneration() === generation - return accountId && isCurrent() ? { accountId, client: current, isCurrent } : null + if (!accountId || !isCurrent()) { + return { kind: 'signed-out' } + } + if (availability === 'offered') { + return { kind: 'connected', connection: { accountId, client: current, isCurrent } } + } + return availability === 'unavailable' + ? { kind: 'unreachable', accountId } + : { kind: 'signed-out' } } diff --git a/src/main/agent-api-keys/agent-api-key-cloud-ledger.ts b/src/main/agent-api-keys/agent-api-key-cloud-ledger.ts new file mode 100644 index 00000000000..29b432af21e --- /dev/null +++ b/src/main/agent-api-keys/agent-api-key-cloud-ledger.ts @@ -0,0 +1,152 @@ +// The A5 sync ledger: per Orca account, which variables this computer wrote (and from which vault +// key) plus saves still waiting to reach the account. Names, ids and timestamps only; never values. +import { readFile } from 'node:fs/promises' +import { writeSecureFile } from '../../shared/secure-storage/secure-file' +import type { AgentApiKeySummary } from '../../shared/agent-api-keys/agent-api-key-catalog' + +export type LedgerEntry = { + /** The vault key whose value was written. */ + keyId: string + /** That key's `updatedAt` when it was written, so a later edit that failed to sync isn't "synced". */ + keyUpdatedAt: number + syncedAt: number +} + +export type LedgerFile = { + version: 1 + /** accountId → variable → what this computer wrote there. */ + accounts: Record> + /** + * accountId → key id → that key's `updatedAt`: saves made while signed in to this account that + * haven't reached it yet. Retried on reconnect and at start; nothing else is ever uploaded unasked. + */ + pending?: Record> +} + +const MAX_LEDGER_BYTES = 256 * 1024 + +function isEntry(value: unknown): value is LedgerEntry { + return ( + typeof value === 'object' && + value !== null && + 'keyId' in value && + 'keyUpdatedAt' in value && + 'syncedAt' in value && + typeof value.keyId === 'string' && + typeof value.keyUpdatedAt === 'number' && + typeof value.syncedAt === 'number' + ) +} + +export function parseLedger(text: string): LedgerFile { + const ledger: LedgerFile = { version: 1, accounts: {} } + if (text.length > MAX_LEDGER_BYTES) { + return ledger + } + let parsed: unknown + try { + parsed = JSON.parse(text) + } catch { + return ledger + } + if ( + typeof parsed !== 'object' || + parsed === null || + !('version' in parsed) || + parsed.version !== 1 || + !('accounts' in parsed) || + typeof parsed.accounts !== 'object' || + parsed.accounts === null + ) { + return ledger + } + for (const [accountId, names] of Object.entries(parsed.accounts)) { + if (typeof names !== 'object' || names === null) { + continue + } + const kept: Record = {} + for (const [name, entry] of Object.entries(names)) { + if (isEntry(entry)) { + kept[name] = entry + } + } + ledger.accounts[accountId] = kept + } + if ('pending' in parsed && typeof parsed.pending === 'object' && parsed.pending !== null) { + const pending: Record> = {} + for (const [accountId, keys] of Object.entries(parsed.pending)) { + if (typeof keys !== 'object' || keys === null) { + continue + } + pending[accountId] = Object.fromEntries( + Object.entries(keys).filter( + (entry): entry is [string, number] => typeof entry[1] === 'number' + ) + ) + } + ledger.pending = pending + } + return ledger +} + +export function pendingOf( + keys: readonly AgentApiKeySummary[], + pending: Record +): { pending?: string[] } { + const ids = keys.filter((key) => pending[key.id] === key.updatedAt).map((key) => key.id) + return ids.length > 0 ? { pending: ids } : {} +} + +/** The variables `keyId` wrote to the account (more than one after a rename). */ +export function namesWrittenBy(names: Record, keyId: string): string[] { + return Object.entries(names) + .filter(([, entry]) => entry.keyId === keyId) + .map(([name]) => name) +} + +/** The ledger file, cached: the sync is its only writer. Written 0600. */ +export class CloudKeyLedger { + private cached: LedgerFile | null = null + + constructor(private readonly path: string) {} + + async read(): Promise { + if (this.cached) { + return this.cached + } + let text = '' + try { + text = await readFile(this.path, 'utf8') + } catch { + // Missing or unreadable: nothing was synced from here that we can prove, so remove nothing. + } + return (this.cached = parseLedger(text)) + } + + private write(next: LedgerFile): void { + writeSecureFile(this.path, JSON.stringify(next, null, 2)) + this.cached = next + } + + async setNames(accountId: string, names: Record): Promise { + const ledger = await this.read() + this.write({ ...ledger, accounts: { ...ledger.accounts, [accountId]: names } }) + } + + /** Marks (a version of) a key as waiting for the account, or clears it. True when one was added. */ + async setPending(accountId: string, keyId: string, updatedAt: number | null): Promise { + const ledger = await this.read() + const current = ledger.pending?.[accountId] ?? {} + if ((current[keyId] ?? null) === updatedAt) { + return false + } + const { [keyId]: _old, ...rest } = current + const keys = updatedAt === null ? rest : { ...rest, [keyId]: updatedAt } + this.write({ ...ledger, pending: { ...ledger.pending, [accountId]: keys } }) + return updatedAt !== null + } + + hasPending(): boolean { + return Object.values(this.cached?.pending ?? {}).some((keys) => Object.keys(keys).length > 0) + } +} diff --git a/src/main/agent-api-keys/agent-api-key-cloud-retry.test.ts b/src/main/agent-api-keys/agent-api-key-cloud-retry.test.ts new file mode 100644 index 00000000000..6fc11b65783 --- /dev/null +++ b/src/main/agent-api-keys/agent-api-key-cloud-retry.test.ts @@ -0,0 +1,81 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { createAgentApiKeyCloudRetry } from './agent-api-key-cloud-retry' + +type Link = 'connected' | 'unreachable' | 'signed-out' | null + +beforeEach(() => { + vi.useFakeTimers() +}) +afterEach(() => { + vi.useRealTimers() +}) + +function fakeCloud() { + const cloud: { + lastLink: Link + pending: boolean + hasPending: () => boolean + flushPending: ReturnType Promise>> + } = { + lastLink: null, + pending: false, + hasPending: () => cloud.pending, + flushPending: vi.fn(async () => false) + } + return cloud +} + +describe('createAgentApiKeyCloudRetry', () => { + it('runs only when kicked, backs off while Orca is unreachable, and stops once it is back', async () => { + const cloud = fakeCloud() + const notify = vi.fn() + const retry = createAgentApiKeyCloudRetry({ + cloud, + serial: (run) => run(), + notify, + firstDelayMs: 10, + maxDelayMs: 40 + }) + await vi.advanceTimersByTimeAsync(1000) + expect(cloud.flushPending).not.toHaveBeenCalled() + + cloud.lastLink = 'unreachable' + retry.kick() + await vi.advanceTimersByTimeAsync(10) + expect(cloud.flushPending).toHaveBeenCalledTimes(1) + await vi.advanceTimersByTimeAsync(19) + expect(cloud.flushPending).toHaveBeenCalledTimes(1) + await vi.advanceTimersByTimeAsync(1) + expect(cloud.flushPending).toHaveBeenCalledTimes(2) + + cloud.flushPending.mockImplementationOnce(async () => { + cloud.lastLink = 'connected' + return true + }) + await vi.advanceTimersByTimeAsync(40) + expect(cloud.flushPending).toHaveBeenCalledTimes(3) + expect(notify).toHaveBeenCalledTimes(1) + await vi.advanceTimersByTimeAsync(10_000) + expect(cloud.flushPending).toHaveBeenCalledTimes(3) + retry.stop() + }) + + it('a soon kick (wake, start) resets the backoff', async () => { + const cloud = fakeCloud() + cloud.pending = true + const retry = createAgentApiKeyCloudRetry({ + cloud, + serial: (run) => run(), + notify: () => {}, + firstDelayMs: 10, + maxDelayMs: 1000 + }) + retry.kick() + await vi.advanceTimersByTimeAsync(10 + 20 + 40) + expect(cloud.flushPending).toHaveBeenCalledTimes(3) + retry.kick({ soon: true }) + await vi.advanceTimersByTimeAsync(10) + expect(cloud.flushPending).toHaveBeenCalledTimes(4) + retry.stop() + }) +}) diff --git a/src/main/agent-api-keys/agent-api-key-cloud-retry.ts b/src/main/agent-api-keys/agent-api-key-cloud-retry.ts new file mode 100644 index 00000000000..3806120d8c4 --- /dev/null +++ b/src/main/agent-api-keys/agent-api-key-cloud-retry.ts @@ -0,0 +1,77 @@ +// Saves made while signed in that didn't reach the Orca account (offline, a failed request) are +// retried at start, on wake, and with backoff while Orca is unreachable or a save is pending. The +// timer stops as soon as there is nothing to wait for; the sync kicks it again when there is. +import type { AgentApiKeyCloudSync } from './agent-api-key-cloud-sync' + +const FIRST_DELAY_MS = 15_000 +const MAX_DELAY_MS = 15 * 60_000 + +export type AgentApiKeyCloudRetry = { + /** Something is waiting (a pending save, Orca unreachable) or the network may be back. */ + kick: (options?: { soon?: boolean }) => void + stop: () => void +} + +export function createAgentApiKeyCloudRetry({ + cloud, + serial, + notify, + firstDelayMs = FIRST_DELAY_MS, + maxDelayMs = MAX_DELAY_MS +}: { + cloud: Pick + serial: (run: () => Promise) => Promise + /** Tells open windows to re-read the keys' state. */ + notify: () => void + firstDelayMs?: number + maxDelayMs?: number +}): AgentApiKeyCloudRetry { + let timer: ReturnType | null = null + let delay = firstDelayMs + let stopped = false + const waiting = (): boolean => cloud.lastLink === 'unreachable' || cloud.hasPending() + + const run = async (): Promise => { + timer = null + try { + const before = cloud.lastLink + const changed = await serial(() => cloud.flushPending()) + if (changed || cloud.lastLink !== before) { + notify() + } + } catch { + // Treated like any other miss: back off and try again. + } + if (waiting()) { + delay = Math.min(delay * 2, maxDelayMs) + schedule() + } else { + delay = firstDelayMs + } + } + const schedule = (): void => { + if (stopped || timer) { + return + } + timer = setTimeout(() => void run(), delay) + timer.unref?.() + } + return { + kick: ({ soon = false } = {}) => { + if (soon) { + delay = firstDelayMs + if (timer) { + clearTimeout(timer) + timer = null + } + } + schedule() + }, + stop: () => { + stopped = true + if (timer) { + clearTimeout(timer) + } + } + } +} diff --git a/src/main/agent-api-keys/agent-api-key-cloud-sync.test.ts b/src/main/agent-api-keys/agent-api-key-cloud-sync.test.ts index 82ac3ee469c..6ab5d2064e7 100644 --- a/src/main/agent-api-keys/agent-api-key-cloud-sync.test.ts +++ b/src/main/agent-api-keys/agent-api-key-cloud-sync.test.ts @@ -41,9 +41,15 @@ function setup(accountId: string | null = 'user-a', vault: AgentApiKeySummary[] return { accountId: id, client, isCurrent: () => generation === at } } let current: AgentApiKeyCloudConnection | null = accountId ? connect(accountId) : null + let offline = false const sync = new AgentApiKeyCloudSync({ ledgerPath: join(root, 'ledger.json'), - connection: async () => current, + link: async () => + !current + ? { kind: 'signed-out' } + : offline + ? { kind: 'unreachable', accountId: current.accountId } + : { kind: 'connected', connection: current }, valueOf: async () => VALUE, listKeys: async () => vault, now: () => 100 @@ -54,6 +60,9 @@ function setup(accountId: string | null = 'user-a', vault: AgentApiKeySummary[] signInAs: (id: string | null) => { generation++ current = id ? connect(id) : null + }, + setOffline: (next: boolean) => { + offline = next } } } @@ -106,7 +115,12 @@ describe('AgentApiKeyCloudSync', () => { expect(outcome).toEqual({ kind: 'failed', error: 'unavailable', keyId: 'k1' }) expect(JSON.stringify(outcome)).not.toContain(VALUE) expect(JSON.stringify(warn.mock.calls)).not.toContain(VALUE) - expect(await sync.state([key()])).toEqual({ signedIn: true, synced: [], managed: [] }) + expect(await sync.state([key()])).toEqual({ + signedIn: true, + synced: [], + managed: [], + pending: ['k1'] + }) warn.mockRestore() }) @@ -116,7 +130,12 @@ describe('AgentApiKeyCloudSync', () => { client.put.mockRejectedValueOnce(new EnvironmentProviderError('timeout', 'slow')) const edited = key({ updatedAt: 2, hint: 'zzzz' }) await sync.push(edited) - expect(await sync.state([edited])).toEqual({ signedIn: true, synced: [], managed: ['k1'] }) + expect(await sync.state([edited])).toEqual({ + signedIn: true, + synced: [], + managed: ['k1'], + pending: ['k1'] + }) }) it('keeps one ledger per Orca account', async () => { @@ -257,4 +276,65 @@ describe('AgentApiKeyCloudSync', () => { } ) }) + + it('shows the last-known state while Orca is unreachable, and nothing for an account never connected here', async () => { + const { sync, setOffline } = setup() + setOffline(true) + expect(await sync.state([key()])).toEqual({ signedIn: false, synced: [], managed: [] }) + setOffline(false) + await sync.push(key()) + setOffline(true) + expect(await sync.state([key()])).toEqual({ + signedIn: true, + unreachable: true, + synced: ['k1'], + managed: ['k1'] + }) + const ledger = await readFile(join(root, 'ledger.json'), 'utf8') + expect(ledger).not.toContain(VALUE) + }) + + it('queues a save made while offline and sends it when Orca is back, once', async () => { + const edited = key({ updatedAt: 2 }) + const { client, sync, setOffline } = setup('user-a', [edited]) + await sync.push(key()) + setOffline(true) + expect(await sync.push(edited)).toEqual({ kind: 'failed', error: 'unavailable', keyId: 'k1' }) + expect(await sync.state([edited])).toMatchObject({ unreachable: true, pending: ['k1'] }) + expect(sync.hasPending()).toBe(true) + expect(await sync.flushPending()).toBe(false) + setOffline(false) + expect(await sync.flushPending()).toBe(true) + expect(client.put).toHaveBeenCalledTimes(2) + expect(await sync.state([edited])).toEqual({ signedIn: true, synced: ['k1'], managed: ['k1'] }) + expect(await sync.flushPending()).toBe(false) + expect(client.put).toHaveBeenCalledTimes(2) + }) + + it('retries a failed request, but drops keys edited or removed since and non-transient failures', async () => { + const other = key({ id: 'k2', envName: 'OPENAI_API_KEY' }) + const vault = [key(), other] + const { client, sync } = setup('user-a', vault) + vi.spyOn(console, 'warn').mockImplementation(() => {}) + client.put.mockRejectedValueOnce(new EnvironmentProviderError('timeout', 'slow')) + client.put.mockRejectedValueOnce(new EnvironmentProviderError('timeout', 'slow')) + await sync.push(key()) + await sync.push(other) + expect(await sync.state(vault)).toMatchObject({ pending: ['k1', 'k2'] }) + // k1 was edited since its failed save: the user's newer save decides, not the retry. + vault[0] = key({ updatedAt: 9 }) + expect(await sync.flushPending()).toBe(true) + expect(client.put).toHaveBeenCalledTimes(3) + expect(client.put).toHaveBeenLastCalledWith({ scope: 'personal' }, 'OPENAI_API_KEY', VALUE) + expect(sync.hasPending()).toBe(false) + vi.mocked(console.warn).mockRestore() + }) + + it('never queues keys saved while signed out', async () => { + const { client, sync, signInAs } = setup(null, [key()]) + await sync.push(key()) + signInAs('user-a') + expect(await sync.flushPending()).toBe(false) + expect(client.put).not.toHaveBeenCalled() + }) }) diff --git a/src/main/agent-api-keys/agent-api-key-cloud-sync.ts b/src/main/agent-api-keys/agent-api-key-cloud-sync.ts index f086e1b6f52..498ff8e8803 100644 --- a/src/main/agent-api-keys/agent-api-key-cloud-sync.ts +++ b/src/main/agent-api-keys/agent-api-key-cloud-sync.ts @@ -2,8 +2,6 @@ // secret of the same variable. Cloud secrets are write-only, so this is one way (desktop → account), // and a key removed here leaves the account copy alone unless this computer wrote it and the user // confirms. The ledger records which variables this computer wrote, per account; it holds no values. -import { readFile } from 'node:fs/promises' -import { writeSecureFile } from '../../shared/secure-storage/secure-file' import type { AgentApiKeySummary } from '../../shared/agent-api-keys/agent-api-key-catalog' import { agentApiKeyCloudEligible, @@ -16,6 +14,13 @@ import { cloudSecretsFailureCode, type CloudSecretsClient } from '../cloud-secrets/cloud-secrets-client' +import { + CloudKeyLedger, + namesWrittenBy, + pendingOf, + type LedgerEntry, + type LedgerFile +} from './agent-api-key-cloud-ledger' /** The signed-in account that can hold personal Cloud secrets, or null (signed out, no Cloud). */ export type AgentApiKeyCloudConnection = { @@ -25,137 +30,116 @@ export type AgentApiKeyCloudConnection = { isCurrent: () => boolean } -type LedgerEntry = { - /** The vault key whose value was written. */ - keyId: string - /** That key's `updatedAt` when it was written, so a later edit that failed to sync isn't "synced". */ - keyUpdatedAt: number - syncedAt: number -} +/** + * Where the desktop stands with the Orca account. `unreachable`: signed in, but Orca can't be + * reached now (offline, or the session refresh failed); rows keep their last-known state. + */ +export type AgentApiKeyCloudLink = + | { kind: 'connected'; connection: AgentApiKeyCloudConnection } + | { kind: 'unreachable'; accountId: string } + | { kind: 'signed-out' } -type LedgerFile = { - version: 1 - /** accountId → variable → what this computer wrote there. */ - accounts: Record> -} +/** Failures worth retrying on their own; anything else needs the user. */ +const TRANSIENT: ReadonlySet = new Set([ + 'unavailable', + 'timeout', + 'unknown', + 'unauthorized' +]) -const MAX_LEDGER_BYTES = 256 * 1024 const PERSONAL = { scope: 'personal' } as const -function isEntry(value: unknown): value is LedgerEntry { - return ( - typeof value === 'object' && - value !== null && - 'keyId' in value && - 'keyUpdatedAt' in value && - 'syncedAt' in value && - typeof value.keyId === 'string' && - typeof value.keyUpdatedAt === 'number' && - typeof value.syncedAt === 'number' - ) -} - -function parseLedger(text: string): LedgerFile { - const ledger: LedgerFile = { version: 1, accounts: {} } - if (text.length > MAX_LEDGER_BYTES) { - return ledger - } - let parsed: unknown - try { - parsed = JSON.parse(text) - } catch { - return ledger - } - if ( - typeof parsed !== 'object' || - parsed === null || - !('version' in parsed) || - parsed.version !== 1 || - !('accounts' in parsed) || - typeof parsed.accounts !== 'object' || - parsed.accounts === null - ) { - return ledger - } - for (const [accountId, names] of Object.entries(parsed.accounts)) { - if (typeof names !== 'object' || names === null) { - continue - } - const kept: Record = {} - for (const [name, entry] of Object.entries(names)) { - if (isEntry(entry)) { - kept[name] = entry - } - } - ledger.accounts[accountId] = kept - } - return ledger -} - export type AgentApiKeyCloudSyncOptions = { ledgerPath: string - /** Null when signed out of Orca or Orca Cloud isn't offered: keys then stay on this computer. */ - connection: () => Promise + /** Signed out (or no Orca Cloud): keys stay on this computer. */ + link: () => Promise /** Unseals one vault key for a single write. */ valueOf: (keyId: string) => Promise /** The vault's keys now, to tell whether another key owns a variable's account copy. */ listKeys: () => Promise + /** Called when something now waits on Orca (it's unreachable, or a save is pending). */ + onWaiting?: () => void now?: () => number } -/** The variables `keyId` wrote to the account (more than one after a rename). */ -function namesWrittenBy(names: Record, keyId: string): string[] { - return Object.entries(names) - .filter(([, entry]) => entry.keyId === keyId) - .map(([name]) => name) -} - export class AgentApiKeyCloudSync { - private cached: LedgerFile | null = null + private readonly book: CloudKeyLedger - constructor(private readonly options: AgentApiKeyCloudSyncOptions) {} + constructor(private readonly options: AgentApiKeyCloudSyncOptions) { + this.book = new CloudKeyLedger(options.ledgerPath) + } private now(): number { return this.options.now?.() ?? Date.now() } - private async ledger(): Promise { - if (this.cached) { - return this.cached - } - let text = '' - try { - text = await readFile(this.options.ledgerPath, 'utf8') - } catch { - // Missing or unreadable: nothing was synced from here that we can prove, so remove nothing. - } - return (this.cached = parseLedger(text)) + private ledger(): Promise { + return this.book.read() } - private async setNames(accountId: string, names: Record): Promise { - const ledger = await this.ledger() - const next: LedgerFile = { ...ledger, accounts: { ...ledger.accounts, [accountId]: names } } - writeSecureFile(this.options.ledgerPath, JSON.stringify(next, null, 2)) - this.cached = next + private setNames(accountId: string, names: Record): Promise { + return this.book.setNames(accountId, names) + } + + private async setPending( + accountId: string, + keyId: string, + updatedAt: number | null + ): Promise { + if (await this.book.setPending(accountId, keyId, updatedAt)) { + this.options.onWaiting?.() + } + } + + /** The last link seen, so the reconnect check costs nothing while there's nothing to wait for. */ + lastLink: AgentApiKeyCloudLink['kind'] | null = null + + private async link(): Promise { + let link: AgentApiKeyCloudLink + try { + link = await this.options.link() + } catch { + link = { kind: 'signed-out' } + } + this.lastLink = link.kind + if (link.kind === 'unreachable') { + this.options.onWaiting?.() + } + return link } private async connection(): Promise { - try { - return await this.options.connection() - } catch { - return null - } + const link = await this.link() + return link.kind === 'connected' ? link.connection : null + } + + /** Saves waiting to reach the account, for any account (cheap: the ledger is cached). */ + hasPending(): boolean { + return this.book.hasPending() } async state(keys: readonly AgentApiKeySummary[]): Promise { - const connection = await this.connection() - if (!connection) { + const link = await this.link() + if (link.kind === 'signed-out') { return { signedIn: false, synced: [], managed: [] } } - const names = (await this.ledger()).accounts[connection.accountId] ?? {} + const accountId = link.kind === 'connected' ? link.connection.accountId : link.accountId + const ledger = await this.ledger() + if (link.kind === 'unreachable' && !ledger.accounts[accountId]) { + // Never connected from here: nothing known to show, so this reads as signed out. + return { signedIn: false, synced: [], managed: [] } + } + if (link.kind === 'connected' && !ledger.accounts[accountId]) { + // Remember the account was connected, so a later offline spell shows its last-known state. + await this.setNames(accountId, {}) + } + const names = (await this.ledger()).accounts[accountId] ?? {} + const pending = (await this.ledger()).pending?.[accountId] ?? {} const managed = keys.filter((key) => namesWrittenBy(names, key.id).length > 0) return { signedIn: true, + ...(link.kind === 'unreachable' ? { unreachable: true } : {}), + ...pendingOf(keys, pending), managed: managed.map((key) => key.id), synced: managed .filter((key) => { @@ -180,8 +164,8 @@ export class AgentApiKeyCloudSync { key: AgentApiKeySummary, { replace = false }: { replace?: boolean } = {} ): Promise { - const connection = await this.connection() - if (!connection || key.hostScope.kind !== 'all') { + const link = await this.link() + if (link.kind === 'signed-out' || key.hostScope.kind !== 'all') { return { kind: 'skipped' } } const failed = (error: CloudSecretsErrorCode): AgentApiKeyCloudOutcome => ({ @@ -192,6 +176,22 @@ export class AgentApiKeyCloudSync { if (!agentApiKeyCloudEligible(key)) { return failed('not_swappable') } + if (link.kind === 'unreachable') { + // Saved while signed in: it goes to the account as soon as Orca is reachable again. + if ((await this.ledger()).accounts[link.accountId]) { + await this.setPending(link.accountId, key.id, key.updatedAt) + } + return failed('unavailable') + } + const { connection } = link + const retryLater = async (error: CloudSecretsErrorCode): Promise => { + await this.setPending( + connection.accountId, + key.id, + TRANSIENT.has(error) ? key.updatedAt : null + ) + return failed(error) + } const owner = (await this.ledger()).accounts[connection.accountId]?.[key.envName]?.keyId if ( !replace && @@ -199,7 +199,7 @@ export class AgentApiKeyCloudSync { owner !== key.id && (await this.options.listKeys()).some((other) => other.id === owner) ) { - return failed('desktop_key_conflict') + return retryLater('desktop_key_conflict') } const value = await this.options.valueOf(key.id) if (!value) { @@ -212,7 +212,7 @@ export class AgentApiKeyCloudSync { try { await connection.client.put(PERSONAL, key.envName, value) } catch (error) { - return failed(logged('save', cloudSecretsFailureCode(error))) + return retryLater(logged('save', cloudSecretsFailureCode(error))) } // A sign-in or account switch mid-write: the token may have been another account's, so this // computer can't claim the variable (and must never later delete it on that claim). @@ -222,9 +222,38 @@ export class AgentApiKeyCloudSync { const names = { ...(await this.ledger()).accounts[connection.accountId] } names[key.envName] = { keyId: key.id, keyUpdatedAt: key.updatedAt, syncedAt: this.now() } await this.setNames(connection.accountId, names) + await this.setPending(connection.accountId, key.id, null) return { kind: 'synced' } } + /** + * Retries saves the user made while signed in that haven't reached the account. Only those keys, + * only at the version that was saved: a key edited, rescoped or removed since is dropped. + * Returns whether anything changed. + */ + async flushPending(): Promise { + const connection = await this.connection() + const pending = connection ? (await this.ledger()).pending?.[connection.accountId] : undefined + if (!connection || !pending || Object.keys(pending).length === 0) { + return false + } + const keys = await this.options.listKeys() + let changed = false + for (const [keyId, updatedAt] of Object.entries(pending)) { + const key = keys.find((entry) => entry.id === keyId) + if (!key || key.updatedAt !== updatedAt || !agentApiKeyCloudEligible(key)) { + await this.setPending(connection.accountId, keyId, null) + continue + } + const outcome = await this.push(key) + changed ||= outcome.kind === 'synced' + if (outcome.kind === 'failed' && TRANSIENT.has(outcome.error)) { + break // Still unreachable: try again on the next check. + } + } + return changed + } + /** Records a write of `key` made elsewhere (the cloud workspace setup's "Save to your Orca account"). */ async record(key: AgentApiKeySummary): Promise { const connection = await this.connection() @@ -288,6 +317,7 @@ export class AgentApiKeyCloudSync { Object.entries(names).filter(([, entry]) => entry.keyId !== key.id) ) await this.setNames(connection.accountId, rest) + await this.setPending(connection.accountId, key.id, null) } } } diff --git a/src/main/agent-api-keys/agent-api-key-ipc.ts b/src/main/agent-api-keys/agent-api-key-ipc.ts index 072360f5ee6..0786c695335 100644 --- a/src/main/agent-api-keys/agent-api-key-ipc.ts +++ b/src/main/agent-api-keys/agent-api-key-ipc.ts @@ -1,4 +1,4 @@ -import { ipcMain } from 'electron' +import { BrowserWindow, ipcMain, powerMonitor } from 'electron' import { join } from 'node:path' import { selectAgentApiKeys, @@ -9,10 +9,11 @@ import { AgentApiKeyStore } from './agent-api-key-store' import { mutate, stateOf } from './agent-api-key-state' import { installAgentApiKeyLaunchEnvResolver } from './agent-api-key-launch-env' import { AgentApiKeyCloudSync } from './agent-api-key-cloud-sync' +import { agentApiKeyCloudLink, setAgentApiKeyCloudRecorder } from './agent-api-key-cloud-connection' import { - agentApiKeyCloudConnection, - setAgentApiKeyCloudRecorder -} from './agent-api-key-cloud-connection' + createAgentApiKeyCloudRetry, + type AgentApiKeyCloudRetry +} from './agent-api-key-cloud-retry' import { registerAgentApiKeyCloudHandlers, removeRequestOf } from './agent-api-key-cloud-ipc' /** A host id no host-scoped key names, as in desktopKeyValueForCloud. */ @@ -20,14 +21,18 @@ const ANY_CLOUD_HOST = toRuntimeExecutionHostId('orca-cloud') const CHANNELS = ['agentApiKeys:list', 'agentApiKeys:save', 'agentApiKeys:remove'] as const +let retry: AgentApiKeyCloudRetry | null = null +let wakeHooked = false + /** Values only ever travel renderer → main here; nothing returns them. */ export function registerAgentApiKeyHandlers(userDataPath: string): AgentApiKeyStore { const store = new AgentApiKeyStore(join(userDataPath, 'agent-api-keys.json')) const cloud = new AgentApiKeyCloudSync({ ledgerPath: join(userDataPath, 'agent-api-keys-cloud-ledger.json'), - connection: agentApiKeyCloudConnection, + link: agentApiKeyCloudLink, valueOf: (id) => store.valueOf(id), - listKeys: () => store.list() + listKeys: () => store.list(), + onWaiting: () => retry?.kick() }) // Saves, removals and imports touch the vault and the ledger; one at a time keeps them in step. let queue: Promise = Promise.resolve() @@ -74,5 +79,24 @@ export function registerAgentApiKeyHandlers(userDataPath: string): AgentApiKeySt }) ) registerAgentApiKeyCloudHandlers({ store, cloud, serial }) + retry?.stop() + retry = createAgentApiKeyCloudRetry({ + cloud, + serial, + notify: () => { + for (const window of BrowserWindow.getAllWindows()) { + if (!window.isDestroyed()) { + window.webContents.send('agentApiKeys:changed') + } + } + } + }) + // At start (a save from last session may be waiting) and after sleep, when the network returns. + retry.kick({ soon: true }) + if (!wakeHooked) { + wakeHooked = true + powerMonitor.on('resume', () => retry?.kick({ soon: true })) + powerMonitor.on('unlock-screen', () => retry?.kick({ soon: true })) + } return store } diff --git a/src/preload/api/agent-api-keys-bridge.ts b/src/preload/api/agent-api-keys-bridge.ts index 876327296af..5a05698bbf9 100644 --- a/src/preload/api/agent-api-keys-bridge.ts +++ b/src/preload/api/agent-api-keys-bridge.ts @@ -21,6 +21,8 @@ export type AgentApiKeysApi = { /** Keys this computer already uses: names, sources and last fours only. */ scanThisComputer?: () => Promise importFromThisComputer?: (names: string[]) => Promise + /** Main re-synced or reconnected: re-read `list`. Returns the unsubscribe. */ + onChanged?: (listener: () => void) => () => void } export const agentApiKeysApi: AgentApiKeysApi = { @@ -29,6 +31,11 @@ export const agentApiKeysApi: AgentApiKeysApi = { remove: (request) => ipcRenderer.invoke('agentApiKeys:remove', request), saveToAccount: (id) => ipcRenderer.invoke('agentApiKeys:saveToAccount', id), scanThisComputer: () => ipcRenderer.invoke('agentApiKeys:scanThisComputer'), + onChanged: (listener) => { + const handler = (): void => listener() + ipcRenderer.on('agentApiKeys:changed', handler) + return () => ipcRenderer.removeListener('agentApiKeys:changed', handler) + }, importFromThisComputer: (names) => ipcRenderer.invoke('agentApiKeys:importFromThisComputer', names) } diff --git a/src/renderer/src/components/settings/agent-api-keys/AgentApiKeyCloudLine.tsx b/src/renderer/src/components/settings/agent-api-keys/AgentApiKeyCloudLine.tsx index 343b4907bd3..2ac2a5fa1e4 100644 --- a/src/renderer/src/components/settings/agent-api-keys/AgentApiKeyCloudLine.tsx +++ b/src/renderer/src/components/settings/agent-api-keys/AgentApiKeyCloudLine.tsx @@ -12,6 +12,7 @@ export function AgentApiKeyCloudLine({ envName, state, canSave, + offline = false, failure, onSaveToAccount }: { @@ -19,6 +20,8 @@ export function AgentApiKeyCloudLine({ state: AgentApiKeyCloudRowState /** Every host and a variable the proxy swaps. */ canSave: boolean + /** Orca can't be reached: show the last-known state, without actions that would fail. */ + offline?: boolean failure: CloudSecretsErrorCode | undefined onSaveToAccount: () => Promise }): React.JSX.Element | null { @@ -36,7 +39,7 @@ export function AgentApiKeyCloudLine({ setSaving(false) } // A failed account write replaces the status line: one line says what happened and offers retry. - if (failure && canSave && (state === 'local' || state === 'stale')) { + if (failure && canSave && !offline && (state === 'local' || state === 'stale')) { const transport = failure === 'unavailable' || failure === 'timeout' || failure === 'unknown' return (
@@ -91,7 +94,7 @@ export function AgentApiKeyCloudLine({ ) : t('agentApiKeys.cloud.local', 'Only on this computer')} - {canSave && (state === 'local' || state === 'stale') ? ( + {canSave && !offline && (state === 'local' || state === 'stale') ? (
) : null} - + {agents.map((agent) => { @@ -301,6 +311,7 @@ export function AgentApiKeysPane({ { + void api.list().then( + (next) => { + if (!cancelled) { + setState(next) + setCloudFailures((current) => + Object.fromEntries( + Object.entries(current).filter(([id]) => !next.cloud?.synced.includes(id)) + ) + ) + } + }, + () => undefined + ) + }) return () => { cancelled = true + unsubscribe?.() } }, [api]) diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json index 1b1b92194dd..c19daf0e44c 100644 --- a/src/renderer/src/i18n/locales/en.json +++ b/src/renderer/src/i18n/locales/en.json @@ -27508,7 +27508,9 @@ "retry": "Try again", "staleCopy": "Your Orca account has an older copy. Cloud workspaces still use it.", "updateLabel": "Update {{name}} in your Orca account", - "update": "Update your Orca account" + "update": "Update your Orca account", + "unreachable": "Can’t reach your Orca account right now", + "unreachableDetail": "Showing the last known state. Keys you save now go to your Orca account when Orca is back." }, "remove": { "confirmLabel": "Remove {{name}}", diff --git a/src/shared/agent-api-keys/agent-api-key-cloud.ts b/src/shared/agent-api-keys/agent-api-key-cloud.ts index f9ff50ad44a..92ee4543c12 100644 --- a/src/shared/agent-api-keys/agent-api-key-cloud.ts +++ b/src/shared/agent-api-keys/agent-api-key-cloud.ts @@ -9,6 +9,10 @@ import type { AgentApiKeySummary, AgentApiKeysState } from './agent-api-key-cata export type AgentApiKeysCloudState = { /** Signed in to an Orca account that has Orca Cloud; otherwise keys stay on this computer only. */ signedIn: boolean + /** Signed in, but Orca can't be reached now: `synced`/`managed` are the last-known state. */ + unreachable?: boolean + /** Keys saved while signed in that haven't reached the account yet; Orca retries them. */ + pending?: string[] /** Keys whose current value this computer saved to the Orca account. */ synced: string[] /**