diff --git a/cloud/apps/acceptance/live/checkpoints-vm.ts b/cloud/apps/acceptance/live/checkpoints-vm.ts new file mode 100644 index 00000000000..4dbb0419035 --- /dev/null +++ b/cloud/apps/acceptance/live/checkpoints-vm.ts @@ -0,0 +1,377 @@ +// Live proof on a real dev VM (no model spend): per-turn code checkpoints in an Orca Cloud workspace. +// A real Claude Code chat runs in orcad on the VM, with its model pointed at a stand-in on the VM +// (standin-anthropic.py), and the desktop's own E2EE request connection and client capabilities. +// 1. Each message that opens a turn writes one refs/orca/checkpoints//turn/* ref; the user's +// HEAD, staged files and stash list never change. +// 2. Sleep (suspend) and wake (resume): the refs and files are unchanged. A fresh connection, as a +// restarted desktop has, rewinds the chat to turn B and restores its files; Undo brings them back. +// 3. Rollover (host replaced): the refs are still there, a new turn gets its own ref, and the agent's +// context holds only the turns left after the rewind. +// 4. Restart (orcad restarted): rewind to turn A restores the files from before the first turn. +// Dev backends only. The VM is always deleted at the end unless --keep is given. +// Run from the repo root after `pnpm install` there and in cloud/: +// node_modules/.bin/tsx cloud/apps/acceptance/live/checkpoints-vm.ts [--keep] +import { randomUUID } from 'node:crypto' +import { readFileSync } from 'node:fs' +import path from 'node:path' +import { fileURLToPath } from 'node:url' +import { control, vercel } from '../src/clients' +import { RemoteRuntimeRequestConnection } from '../../../../src/shared/remote-runtime/requests/remote-runtime-request-connection' +import { ELECTRON_REMOTE_RUNTIME_CLIENT_CAPABILITIES } from '../../../../src/shared/electron-remote-runtime-client-capabilities' +import { pairedRuntimeConnectionFromOffer } from '../../../../src/shared/remote-runtime/pairing/paired-runtime-connection' +import { parsePairingCode } from '../../../../src/shared/remote-runtime/pairing/pairing' +import { + createStructuredAgentSessionId, + structuredAgentSessionCreateParams +} from '../../../../src/shared/agent-session/structured-agent-session-create' +import { + createStructuredAgentSessionOperationId, + structuredAgentSessionPayloadFingerprint +} from '../../../../src/shared/agent-session/lifecycle/structured-agent-session-mutation' +import { structuredAgentSessionMessageSendMutation } from '../../../../src/shared/agent-session/requests/structured-agent-session-send-mutation' +import { agentJournalSubmissionKey } from '../../../../src/shared/agent-session/journal/agent-session-journal-item-key' +import type { AgentSessionHistoryResult } from '../../../../src/shared/agent-session/agent-session-wire' +import type { + AgentSessionCheckpointPreview, + AgentSessionCheckpointRestoreResult +} from '../../../../src/shared/agent-session/lifecycle/agent-session-checkpoint' + +const REPO = '/vercel/sandbox/ckvm-repo' +const STANDIN = path.join(path.dirname(fileURLToPath(import.meta.url)), 'standin-anthropic.py') +const MODEL = 'claude-sonnet-4-5-20250929' +const who = { sub: `ckvm-${Date.now().toString(36)}` } +const keep = process.argv.includes('--keep') +const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms)) +const since = (t0: number) => Math.round(performance.now() - t0) +type Files = Record +type Vm = { id: string; vsession: string; pairingCode: string } + +const timings: Record = {} +const failures: string[] = [] +function log(line: string): void { + console.log(`${new Date().toISOString()} ${line}`) +} +function check(ok: boolean, what: string): void { + log(`${ok ? 'PASS' : 'FAIL'} ${what}`) + if (!ok) { + failures.push(what) + } +} +const same = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b) + +async function exec(vm: Vm, script: string, timeoutMs = 120_000): Promise { + const r = await vercel().runCommand(vm.vsession, { command: 'bash', args: ['-lc', script], timeoutMs }) + if (r.exitCode !== 0) { + throw new Error(`VM command exited ${r.exitCode}: ${r.stderr.slice(-1500)}`) + } + return r.stdout +} + +/** Every file in the repo except .git and .claude, with its content, as the user sees it. */ +async function files(vm: Vm): Promise { + const out = await exec( + vm, + `cd ${REPO} && find . \\( -name .git -o -name .claude \\) -prune -o -type f -print | sort | while read -r f; do printf '%s\\t%s\\n' "\${f#./}" "$(base64 -w0 < "$f")"; done` + ) + const result: Files = {} + for (const line of out.split('\n').filter(Boolean)) { + const [name, b64] = line.split('\t') + result[name!] = Buffer.from(b64 ?? '', 'base64').toString('utf8') + } + return result +} +const refs = async (vm: Vm) => + (await exec(vm, `cd ${REPO} && git for-each-ref --format='%(refname) %(objectname)' refs/orca/`)).trim().split('\n').filter(Boolean) +const turnRefs = async (vm: Vm) => (await refs(vm)).filter((ref) => ref.includes('/turn/')) +/** HEAD, staged paths, stash count: what checkpoints must never touch. */ +const userGit = (vm: Vm) => + exec(vm, `cd ${REPO} && git rev-parse HEAD && git diff --cached --name-only && git stash list | wc -l`).then((s) => s.trim()) + +/** The desktop's own paired request connection and client capabilities (E2EE WebSocket to orcad). */ +function connect(vm: Vm) { + const offer = parsePairingCode(vm.pairingCode) + if (!offer) { + throw new Error('the control plane returned an unreadable pairing code') + } + const connection = new RemoteRuntimeRequestConnection( + pairedRuntimeConnectionFromOffer(offer), + ELECTRON_REMOTE_RUNTIME_CLIENT_CAPABILITIES + ) + const raw = async (method: string, params: unknown, timeoutMs = 60_000) => { + const response = await connection.request(method, params, timeoutMs) + if (response.ok === false) { + throw new Error(`${method}: ${response.error.message} ${JSON.stringify(response.error.data ?? null)}`) + } + return response + } + const call = async (method: string, params: unknown, timeoutMs?: number) => (await raw(method, params, timeoutMs)).result + return { raw, call, close: () => connection.close() } +} +type Client = ReturnType + +const tail = (client: Client, sessionId: string) => + client.call('agentSession.history', { sessionId, direction: 'tail', limit: 200 }) + +async function startStandin(vm: Vm): Promise { + const source = readFileSync(STANDIN).toString('base64') + await exec(vm, `echo ${source} | base64 -d > /tmp/standin.py; pkill -f '^python3 /tmp/standin[.]py' || true`) + // Detached: a runCommand's process tree ends with the call. + await vercel().startCommand(vm.vsession, { command: 'python3', args: ['/tmp/standin.py'], timeoutMs: 30 * 60_000 }) + const code = await exec( + vm, + `for i in $(seq 1 20); do c=$(curl -s --noproxy '*' -o /dev/null -w '%{http_code}' http://127.0.0.1:8998/v1/models); [ "$c" = 200 ] && break; sleep 0.5; done; echo $c` + ) + if (code.trim() !== '200') { + throw new Error(`stand-in model server did not start (${code.trim()})`) + } +} + +async function lifecycle(vm: Vm, action: 'resume' | 'rollover' | 'restart'): Promise { + const t0 = performance.now() + const r = await control.as(who, 'POST', `/v1/sandboxes/${vm.id}/${action}`) + if (r.status !== 200) { + throw new Error(`${action} -> ${r.status} ${JSON.stringify(r.body).slice(0, 400)}`) + } + timings[action] = since(t0) + vm.vsession = r.body.sandbox.session.id + vm.pairingCode = r.body.connection.pairingCode + log(`${action}: 200 in ${timings[action]} ms`) + await startStandin(vm) +} + +const TURNS: Record = { + A: "printf 'one\\n' > feature.txt", + B: "printf 'v2\\n' > app.txt && rm feature.txt && mkdir -p notes && printf 'later\\n' > notes/todo.txt", + C: "printf 'three\\n' > three.txt && printf 'v3\\n' > app.txt", + D: "printf 'after-rewind\\n' > d.txt", + E: "printf 'e\\n' > e.txt" +} +type Turn = { itemId: string; before: Files; after: Files } + +/** Sends one message and waits until the agent replied and the chat has gone quiet. */ +async function turn(vm: Vm, client: Client, sessionId: string, name: string): Promise { + const before = await files(vm) + const refsBefore = (await turnRefs(vm)).length + const clientOperationId = createStructuredAgentSessionOperationId(randomUUID) + const page = (await tail(client, sessionId)).page + await client.call( + 'agentSession.send', + structuredAgentSessionMessageSendMutation({ + sessionId, + clientOperationId, + expectedRuntimeFence: page.fence ?? 0, + body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: `Turn ${name}. RUN: ${TURNS[name]}` }] }, + delivery: 'queue-if-active' + }), + 120_000 + ) + const itemId = agentJournalSubmissionKey(clientOperationId) + let last = -1 + let quiet = 0 + for (let i = 0; i < 150; i++) { + await sleep(2000) + const items = (await tail(client, sessionId)).page.items + const index = items.findIndex((item) => item.itemId === itemId) + const replied = + index !== -1 && items.slice(index + 1).some((item) => item.body.kind === 'message' && item.body.role === 'assistant') + const newest = items.at(-1)?.sequence ?? -1 + quiet = newest === last ? quiet + 1 : 0 + last = newest + if (replied && quiet >= 3) { + break + } + } + const after = await files(vm) + check((await turnRefs(vm)).length === refsBefore + 1, `turn ${name} wrote one checkpoint ref (${refsBefore} -> ${refsBefore + 1})`) + check(!same(before, after), `turn ${name}: the agent changed files`) + return { itemId, before, after } +} + +/** The "Turn X." markers in the context of the model request that ran this turn's command. */ +async function modelContext(vm: Vm, name: string): Promise { + const lines = (await exec(vm, 'cat /tmp/standin.log')).split('\n') + const line = lines.reverse().find((l) => l.includes(`-> tool ${TURNS[name]!.slice(0, 40)}`)) + return /context=(\[[^\]]*\])/.exec(line ?? '')?.[1] ?? 'none' +} + +async function rewindAndRestore(vm: Vm, client: Client, sessionId: string, name: string, t: Turn, undo: boolean) { + const items = (await tail(client, sessionId)).page.items + check(items.some((item) => item.itemId === t.itemId), `fresh connection: turn ${name}'s message is in the chat (${items.length} items)`) + let t0 = performance.now() + const preview = await client.call('agentSession.checkpointPreview', { sessionId, itemId: t.itemId }) + timings[`preview${name}`] = since(t0) + log(`preview ${name}: ${JSON.stringify(preview)}`) + check(preview.available && !preview.busy && !preview.headMoved, `turn ${name} has a restorable checkpoint`) + const filesBefore = await files(vm) + // As the UI does: rewind the chat first, then restore the files. + let rewound = '' + for (let i = 0; i < 40 && !rewound.includes('"ok":true'); i++) { + const page = (await tail(client, sessionId)).page + const fields = { itemId: t.itemId, expectedEpoch: page.epoch } + const response = await client.raw('agentSession.rewind', { + ...fields, + envelope: { + sessionId, + clientOperationId: createStructuredAgentSessionOperationId(randomUUID), + expectedRuntimeFence: page.fence, + payloadFingerprint: structuredAgentSessionPayloadFingerprint({ method: 'agentSession.rewind', sessionId, fields }) + } + }, 200_000) + rewound = JSON.stringify(response.result) + if (!rewound.includes('"ok":true')) { + await sleep(5000) + } + } + const after = (await tail(client, sessionId)).page.items + check( + rewound.includes('"ok":true') && !after.some((item) => item.itemId === t.itemId), + `rewind ${name}: the chat drops the message and everything after it (${items.length} -> ${after.length} items)` + ) + let restored: AgentSessionCheckpointRestoreResult | undefined + t0 = performance.now() + for (let i = 0; i < 30 && !restored; i++) { + try { + restored = await client.call('agentSession.checkpointRestore', { sessionId, itemId: t.itemId }, 120_000) + } catch (error) { + if (!String(error).includes('busy')) { + throw error + } + await sleep(2000) + } + } + timings[`restore${name}`] = since(t0) + const now = await files(vm) + check(same(now, t.before), `restore ${name}: files are exactly as when turn ${name} was sent (${restored?.changedFiles} changed)`) + if (undo && restored) { + t0 = performance.now() + await client.call('agentSession.checkpointUndo', { sessionId, undoId: restored.undoId }, 120_000) + timings[`undo${name}`] = since(t0) + check(same(await files(vm), filesBefore), `undo ${name}: the agent's later edits are back`) + } +} + +async function main(): Promise { + let t0 = performance.now() + const created = await control.as(who, 'POST', '/v1/sandboxes', { machineSize: 'standard', workspaceId: 'ckvm' }) + if (created.status !== 200) { + throw new Error(`create -> ${created.status} ${JSON.stringify(created.body)}`) + } + timings.create = since(t0) + const vm: Vm = { + id: created.body.sandbox.id, + vsession: created.body.sandbox.session.id, + pairingCode: created.body.connection.pairingCode + } + log(`create: ${vm.id} (${who.sub}) in ${timings.create} ms, region ${created.body.sandbox.region}`) + try { + await startStandin(vm) + const settingsEnv = Buffer.from(JSON.stringify({ + ANTHROPIC_BASE_URL: 'http://127.0.0.1:8998', + ANTHROPIC_AUTH_TOKEN: 'standin-no-cost', + ANTHROPIC_API_KEY: '', + ANTHROPIC_MODEL: MODEL, + ANTHROPIC_SMALL_FAST_MODEL: MODEL, + ANTHROPIC_DEFAULT_HAIKU_MODEL: MODEL, + NO_PROXY: '127.0.0.1,localhost', + CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1' + })).toString('base64') + // Claude Code applies settings.json env over its inherited env: its model is the stand-in. + const setup = await exec(vm, `set -e +f="$HOME/.claude/settings.json"; mkdir -p "$(dirname "$f")"; [ -f "$f" ] || echo '{}' > "$f" +python3 -c 'import json,sys,base64; f=sys.argv[1]; d=json.load(open(f)); d.setdefault("env",{}).update(json.loads(base64.b64decode(sys.argv[2]))); json.dump(d,open(f,"w"))' "$f" ${settingsEnv} +claude --version; cat /opt/orca/runtime/orcad/SOURCE_COMMIT +rm -rf ${REPO}; mkdir -p ${REPO}; cd ${REPO}; git init -q; git config user.name E2E; git config user.email e2e@example.test +printf 'build/\\n' > .gitignore; printf 'v0\\n' > app.txt; git add .; git -c commit.gpgsign=false commit -qm base +printf 'staged by the user\\n' > staged.txt; git add staged.txt`) + log(`VM: ${setup.trim().replace(/\n/g, ', ')}`) + const gitAtStart = await userGit(vm) + + let client = connect(vm) + const added = await client.call<{ repo: { id: string } }>('repo.add', { path: REPO }) + let worktreeId = '' + for (let i = 0; i < 30 && !worktreeId; i++) { + worktreeId = (await client.call<{ worktrees: { id: string }[] }>('worktree.list', { repo: `id:${added.repo.id}` })).worktrees[0]?.id ?? '' + if (!worktreeId) { + await sleep(1000) + } + } + const sessionId = createStructuredAgentSessionId('claude', randomUUID) + await client.call('agentSession.create', structuredAgentSessionCreateParams({ + sessionId, + worktree: `id:${worktreeId}`, + agent: 'claude', + options: { permissionMode: 'full-access' }, + randomUuid: randomUUID + })) + for (let i = 0; i < 60 && !(await tail(client, sessionId)).page.fence; i++) { + await sleep(2000) + } + const runtimeAtStart = (await client.raw('agentSession.history', { sessionId, direction: 'tail', limit: 1 }))._meta.runtimeId + + // 1. One checkpoint per turn; the user's git state untouched. + const turns: Record = {} + for (const name of ['A', 'B', 'C']) { + turns[name] = await turn(vm, client, sessionId, name) + } + check((await userGit(vm)) === gitAtStart, 'HEAD, staged files and stash list unchanged by snapshots') + client.close() + + // 2. Sleep and wake, then a fresh connection (a restarted desktop) rewinds to B and restores. + const refsBeforeSleep = await refs(vm) + const filesBeforeSleep = await files(vm) + t0 = performance.now() + const suspended = await control.as(who, 'POST', `/v1/sandboxes/${vm.id}/suspend`) + timings.suspend = since(t0) + check(suspended.status === 200 && suspended.body.sandbox.status === 'suspended', `suspend -> ${suspended.body?.sandbox?.status} in ${timings.suspend} ms`) + await lifecycle(vm, 'resume') + check(same(await refs(vm), refsBeforeSleep), `after sleep and wake: all ${refsBeforeSleep.length} checkpoint refs are unchanged`) + check(same(await files(vm), filesBeforeSleep), 'after sleep and wake: files unchanged') + client = connect(vm) + await rewindAndRestore(vm, client, sessionId, 'B', turns.B!, true) + check((await userGit(vm)) === gitAtStart, 'after restore and undo: HEAD, staged files and stash list unchanged') + client.close() + + // 3. Rollover: refs survive a new host; a new turn checkpoints; the agent only sees A and D. + const refsBeforeRollover = await refs(vm) + await lifecycle(vm, 'rollover') + check(same(await refs(vm), refsBeforeRollover), `after rollover: all ${refsBeforeRollover.length} refs (turn and undo) are unchanged`) + client = connect(vm) + turns.D = await turn(vm, client, sessionId, 'D') + const contextD = await modelContext(vm, 'D') + check(contextD === "['A', 'D']", `after rewind to B, the agent's context holds only A and D (${contextD})`) + client.close() + + // 4. Restart orcad, then a fresh connection rewinds to the first turn. + await lifecycle(vm, 'restart') + client = connect(vm) + const runtimeNow = (await client.raw('agentSession.history', { sessionId, direction: 'tail', limit: 1 }))._meta.runtimeId + check(runtimeNow !== runtimeAtStart, `orcad is a new process (runtime ${runtimeAtStart.slice(0, 8)} -> ${runtimeNow.slice(0, 8)})`) + await rewindAndRestore(vm, client, sessionId, 'A', turns.A!, false) + turns.E = await turn(vm, client, sessionId, 'E') + const contextE = await modelContext(vm, 'E') + check(contextE === "['E']", `after rewind to A, the agent's context holds only E (${contextE})`) + check((await userGit(vm)) === gitAtStart, 'end: HEAD, staged files and stash list unchanged') + client.close() + log(`refs at the end:\n${(await refs(vm)).join('\n')}`) + } finally { + if (keep) { + log(`--keep: ${vm.id} left running for ${who.sub}`) + } else { + const deleted = await control.as(who, 'DELETE', `/v1/sandboxes/${vm.id}`) + const listed = await control.as(who, 'GET', '/v1/sandboxes') + log(`delete ${vm.id}: ${deleted.status} ${deleted.body?.sandbox?.status}; sandboxes left: ${JSON.stringify(listed.body?.sandboxes?.map((s: { id: string; status: string }) => [s.id, s.status]) ?? [])}`) + } + } +} + +main().then( + () => { + log(`timings (ms): ${JSON.stringify(timings)}`) + log(failures.length ? `FAILED ${failures.length}: ${failures.join('; ')}` : 'checkpoints-vm OK') + process.exit(failures.length ? 1 : 0) + }, + (error: unknown) => { + console.error(error) + process.exit(1) + } +) diff --git a/cloud/apps/acceptance/live/standin-anthropic.py b/cloud/apps/acceptance/live/standin-anthropic.py new file mode 100644 index 00000000000..e409c1629b5 --- /dev/null +++ b/cloud/apps/acceptance/live/standin-anthropic.py @@ -0,0 +1,96 @@ +# No-cost stand-in for the Anthropic Messages API (checkpoints-vm.ts uploads it to the VM and runs it +# at 127.0.0.1:8998). Claude Code uses it as its model, so a chat turn is real Claude Code with real +# tools and no model spend: +# - a user message containing "RUN: " gets one Bash tool_use running that command; +# - a tool_result gets the text "DONE"; +# - anything else (titles, side calls) gets a short text. +# Each request is logged to /tmp/standin.log with the "Turn X." markers in the model's context, which +# shows whether a rewind also rewound what the agent sees. +import http.server, json, re, time, uuid + +LOG = '/tmp/standin.log' + + +def log(line): + with open(LOG, 'a') as f: + f.write(time.strftime('%H:%M:%S ') + line + '\n') + + +def texts(content): + if isinstance(content, str): + return [content] + return [b.get('text', '') for b in (content or []) if isinstance(b, dict) and b.get('type') == 'text'] + + +def decide(body): + messages = body.get('messages') or [] + if not body.get('tools') or not messages: + return ('text', 'ok') + content = messages[-1].get('content') + if isinstance(content, list) and any(isinstance(b, dict) and b.get('type') == 'tool_result' for b in content): + return ('text', 'DONE') + for text in reversed(texts(content)): + if 'RUN:' in text: + return ('tool', text.split('RUN:', 1)[1].split('\n', 1)[0].strip()) + return ('text', 'DONE') + + +class Handler(http.server.BaseHTTPRequestHandler): + protocol_version = 'HTTP/1.1' + + def log_message(self, *args): + pass + + def reply(self, obj, content_type='application/json'): + data = obj if isinstance(obj, bytes) else json.dumps(obj).encode() + self.send_response(200) + self.send_header('content-type', content_type) + self.send_header('content-length', str(len(data))) + self.end_headers() + self.wfile.write(data) + + def do_GET(self): + self.reply({'data': [], 'has_more': False}) + + def do_POST(self): + size = int(self.headers.get('content-length') or 0) + try: + body = json.loads(self.rfile.read(size) or b'{}') + except ValueError: + body = {} + if 'count_tokens' in self.path: + return self.reply({'input_tokens': 10}) + kind, value = decide(body) + model = body.get('model', 'claude-standin') + messages = body.get('messages') or [] + context = [t for m in messages for text in texts(m.get('content')) for t in re.findall(r'Turn ([A-Z])[.]', text)] + log(f'POST {self.path} tools={len(body.get("tools") or [])} msgs={len(messages)} context={context} -> {kind} {value[:160]}') + usage = {'input_tokens': 10, 'output_tokens': 5, 'cache_creation_input_tokens': 0, 'cache_read_input_tokens': 0} + if kind == 'tool': + block = {'type': 'tool_use', 'id': 'toolu_' + uuid.uuid4().hex[:20], 'name': 'Bash', + 'input': {'command': value, 'description': 'Scripted edit'}} + stop = 'tool_use' + else: + block = {'type': 'text', 'text': value} + stop = 'end_turn' + message_id = 'msg_' + uuid.uuid4().hex[:20] + if not body.get('stream'): + return self.reply({'id': message_id, 'type': 'message', 'role': 'assistant', 'model': model, 'content': [block], + 'stop_reason': stop, 'stop_sequence': None, 'usage': usage}) + events = [('message_start', {'type': 'message_start', 'message': { + 'id': message_id, 'type': 'message', 'role': 'assistant', 'model': model, 'content': [], + 'stop_reason': None, 'stop_sequence': None, 'usage': usage}})] + if kind == 'tool': + events.append(('content_block_start', {'type': 'content_block_start', 'index': 0, 'content_block': {**block, 'input': {}}})) + events.append(('content_block_delta', {'type': 'content_block_delta', 'index': 0, + 'delta': {'type': 'input_json_delta', 'partial_json': json.dumps(block['input'])}})) + else: + events.append(('content_block_start', {'type': 'content_block_start', 'index': 0, 'content_block': {'type': 'text', 'text': ''}})) + events.append(('content_block_delta', {'type': 'content_block_delta', 'index': 0, 'delta': {'type': 'text_delta', 'text': value}})) + events.append(('content_block_stop', {'type': 'content_block_stop', 'index': 0})) + events.append(('message_delta', {'type': 'message_delta', 'delta': {'stop_reason': stop, 'stop_sequence': None}, 'usage': {'output_tokens': 5}})) + events.append(('message_stop', {'type': 'message_stop'})) + self.reply(b''.join(f'event: {name}\ndata: {json.dumps(data)}\n\n'.encode() for name, data in events), 'text/event-stream') + + +http.server.ThreadingHTTPServer(('127.0.0.1', 8998), Handler).serve_forever() diff --git a/cloud/apps/acceptance/src/catalog.ts b/cloud/apps/acceptance/src/catalog.ts index 2ac4c349064..0eeddfe9036 100644 --- a/cloud/apps/acceptance/src/catalog.ts +++ b/cloud/apps/acceptance/src/catalog.ts @@ -49,6 +49,7 @@ export const CATALOG: Feature[] = [ { id: 'life.read-asleep-access', section: S.life, feature: 'Read-while-asleep access control: removed member loses access at once (keys deleted), private workspace is owner-only', conductor: 'Org access to server-held chats', owner: 'gap-read-asleep', priority: 'P0', better: 'End-to-end encrypted; server holds only ciphertext' }, { id: 'life.read-asleep-phone', section: S.life, feature: 'Phone shows "Latest from this workspace" for a sleeping workspace without waking it', conductor: 'iOS app reads server-held chats', owner: 'gap-read-asleep', priority: 'P1' }, { id: 'local.checkpoints', section: S.acct, feature: 'Per-turn code checkpoints: revert restores files and chat together', conductor: '0.19 (Claude), 0.44 (Codex) checkpoints', owner: 'gap-checkpoints', priority: 'P0' }, + { id: 'cloud.checkpoints', section: S.life, feature: 'Per-turn checkpoints in a cloud workspace: Rewind restores files and chat on a real VM, after sleep/wake, rollover and an orcad restart (live/checkpoints-vm.ts, no model spend)', conductor: '0.19 (Claude), 0.44 (Codex) checkpoints in cloud', owner: 'checkpoints-vm', priority: 'P0' }, // 1. Substrate { id: 'sub.create', section: S.sub, feature: 'Hosted microVM per workspace, one call / one click', conductor: '0.78 GA', owner: 'core', priority: 'P0' }, { id: 'sub.size', section: S.sub, feature: 'Machine size: Standard 8 vCPU / 16 GB (Conductor parity)', conductor: 'Fixed 8 vCPU / 16 GB', owner: 'core', priority: 'P0' }, diff --git a/cloud/apps/billing/src/index.ts b/cloud/apps/billing/src/index.ts index 7a4c658d575..d4b98e106c7 100644 --- a/cloud/apps/billing/src/index.ts +++ b/cloud/apps/billing/src/index.ts @@ -7,6 +7,7 @@ // POST /v1/billing/portal -> { url } Stripe Customer Portal // POST /v1/billing/team-plans {orgIds} other teams' plan state ("Switch to "), read-only // POST /v1/billing/trial claim the team's one-time trial -> entitlement (trial.ts) +// GET /v1/billing/usage?utcOffset= 30 days of sandbox hours; top members/sandboxes for admins // Stripe: // POST /v1/stripe/webhook signed events // Sandbox control plane (CONTROL_PLANE_TOKEN): @@ -50,6 +51,7 @@ import { OverageRequestSchema, updateOverage } from './overage' import { LiveModeRefusedError, StripeError, createStripeClient, type StripeClient } from './stripe' import { UsageReportSchema, flushMeterReports, recordUsage, validateSegment } from './usage' import { handleStripeWebhook } from './webhook' +import { UsageHistoryQuerySchema, usageHistory } from './usage-history' import { renderReturnPage, returnOutcome } from './return-page' import { BindTeamSchema, @@ -316,6 +318,19 @@ export async function handleRequest(request: Request, env: Env, ctx: ExecutionCo return json(await desktopEntitlement(env, caller, request, now)) } + case 'GET /v1/billing/usage': { + // Any member reads the team's daily hours and their own; the breakdown is owners/admins only. + const caller = await authenticateDesktop(env, request) + if (!caller) { + return json({ error: 'unauthorized' }, 401) + } + const query = UsageHistoryQuerySchema.safeParse(Object.fromEntries(url.searchParams)) + if (!query.success) { + return json({ error: 'invalid_request' }, 400) + } + return json(await usageHistory(env.BILLING_DB, caller, now, query.data.utcOffset)) + } + case 'POST /v1/billing/trial': { // Any member may start the team's trial the first time they pick Orca Cloud (spec B1). const caller = await authenticateDesktop(env, request) diff --git a/cloud/apps/billing/src/overage.ts b/cloud/apps/billing/src/overage.ts index 590e00f1d1f..13a24cb725d 100644 --- a/cloud/apps/billing/src/overage.ts +++ b/cloud/apps/billing/src/overage.ts @@ -2,14 +2,23 @@ // Opting in puts exactly one metered overage item, at STRIPE_PRICE_OVERAGE, on the Stripe // subscription: an item still on an older overage price is moved to the current one rather than a // second added (two items on the same meter would bill the same seconds twice). Opting out stops -// metering immediately but leaves the item, so usage already reported is still invoiced. +// metering immediately. The item is removed once it has nothing left to invoice (no meter report +// this Stripe period): at once if none was sent, otherwise at a sync after the period rolls over, +// so usage already reported is still invoiced and no $0 overage line is left on later invoices. import { z } from 'zod' import type { BillingCaller } from './auth' import { OPEN_STATUSES } from './checkout' import type { Env } from './env' import { planCatalog, planForPrice } from './plans' import type { StripeClient, StripeSubscription } from './stripe' -import { accountSettings, currentSubscription, setOverageSettings, upsertSubscription, type SubscriptionRow } from './store' +import { + accountSettings, + currentSubscription, + meterReportsSince, + setOverageSettings, + upsertSubscription, + type SubscriptionRow +} from './store' export const OverageRequestSchema = z .object({ @@ -51,9 +60,35 @@ export async function updateOverage( ? (await accountSettings(env.BILLING_DB, caller.accountId)).spend_cap_cents : request.spendCapCents await setOverageSettings(env.BILLING_DB, caller.accountId, { optIn: request.enabled, spendCapCents }, now) + if (!request.enabled) { + // Best effort: the opt-out already stops metering; a failed removal is retried by the next sync. + await retireOverageItem(env, stripe, subscription, now).catch((error: unknown) => { + console.error(JSON.stringify({ error: 'retire_overage_item', message: error instanceof Error ? error.message.slice(0, 200) : '' })) + }) + } return { ok: true } } +/** + * Removes an opted-out account's overage item once nothing on it is left to invoice: no meter + * report (sent or pending) since the Stripe period began. Returns whether it removed one. + */ +export async function retireOverageItem(env: Env, stripe: StripeClient, subscription: SubscriptionRow, now: number): Promise { + if (!subscription.overage_item_id) { + return false + } + const settings = await accountSettings(env.BILLING_DB, subscription.account_id) + if (settings.overage_opt_in === 1) { + return false + } + if ((await meterReportsSince(env.BILLING_DB, subscription.account_id, subscription.current_period_start)) > 0) { + return false + } + await stripe.deleteSubscriptionItem(subscription.overage_item_id) + await upsertSubscription(env.BILLING_DB, { ...subscription, overage_enabled: 0, overage_item_id: null, updated_at: now }) + return true +} + /** A metered item that is not a seat price and not the current overage price: an older overage price. */ function isStaleOverageItem(env: Env, item: StripeSubscription['items']['data'][number]): boolean { return ( @@ -84,6 +119,17 @@ async function ensureOverageItem(env: Env, stripe: StripeClient, subscription: S } return replace.id } - // Idempotent per subscription+price, so a retried opt-in cannot add a second item. - return (await stripe.addSubscriptionItem({ subscription: subscription.stripe_subscription_id, price: env.STRIPE_PRICE_OVERAGE })).id + // Idempotent per subscription+price, so a retried opt-in cannot add a second item. Opting out + // can remove the item, so a later opt-in may get the removed item's id replayed (Stripe keeps + // idempotent answers for 24 hours): then add again under a key that names the removed item. + let after: string | undefined + for (let attempt = 0; attempt < 3; attempt++) { + const added = await stripe.addSubscriptionItem({ subscription: subscription.stripe_subscription_id, price: env.STRIPE_PRICE_OVERAGE, after }) + const fresh = await stripe.retrieveSubscription(subscription.stripe_subscription_id) + if (fresh.items.data.some((item) => item.id === added.id)) { + return added.id + } + after = added.id + } + throw new Error('overage_item_replayed') } diff --git a/cloud/apps/billing/src/store.ts b/cloud/apps/billing/src/store.ts index af9f27f66eb..a9c8af04233 100644 --- a/cloud/apps/billing/src/store.ts +++ b/cloud/apps/billing/src/store.ts @@ -220,6 +220,18 @@ export async function insertUsage(db: D1Database, usage: UsageInsert): Promise 0 } +/** Meter reports (any status) for usage that ended since `since`, plus any still pending. */ +export async function meterReportsSince(db: D1Database, accountId: string, since: number): Promise { + const row = await db + .prepare( + `SELECT COUNT(*) AS n FROM meter_reports m JOIN usage_events p ON p.usage_id = m.usage_id + WHERE p.account_id = ?1 AND (m.event_timestamp >= ?2 OR m.status = 'pending')` + ) + .bind(accountId, since) + .first<{ n: number }>() + return row?.n ?? 0 +} + /** Overage seconds already metered (billed) in an allowance window. */ export async function meteredSeconds(db: D1Database, accountId: string, windowStart: number): Promise { const row = await db diff --git a/cloud/apps/billing/src/stripe.ts b/cloud/apps/billing/src/stripe.ts index 8d493a6fd58..30b89ef0b15 100644 --- a/cloud/apps/billing/src/stripe.ts +++ b/cloud/apps/billing/src/stripe.ts @@ -143,13 +143,14 @@ export function createStripeClient(env: Env, fetchImpl: typeof fetch = fetch) { idempotencyKey ) }, - addSubscriptionItem(args: { subscription: string; price: string }) { + /** `after`: the id a replayed add returned for an item since removed, so this add is a new one. */ + addSubscriptionItem(args: { subscription: string; price: string; after?: string }) { return request<{ id: string }>( 'POST', '/v1/subscription_items', // Metered: nothing to prorate; usage is billed in arrears. { subscription: args.subscription, price: args.price, proration_behavior: 'none' }, - `overage-item:${args.subscription}:${args.price}` + `overage-item:${args.subscription}:${args.price}${args.after ? `:after:${args.after}` : ''}` ) }, /** Moves an item to another price in place (an older overage price to the current one). */ diff --git a/cloud/apps/billing/src/usage-history.ts b/cloud/apps/billing/src/usage-history.ts new file mode 100644 index 00000000000..55f4ac11436 --- /dev/null +++ b/cloud/apps/billing/src/usage-history.ts @@ -0,0 +1,103 @@ +// Usage history for Plan & billing: sandbox hours per day for the last 30 days, the caller's own +// share, and (for owners and admins only) the top members and sandboxes. Read-only over +// usage_events; hours are the same weighted seconds the included-hours meter counts. A segment +// counts on the day it ended, as it counts in the allowance window it ended in. +import { z } from 'zod' +import type { BillingCaller } from './auth' + +export const USAGE_HISTORY_DAYS = 30 +export const USAGE_HISTORY_TOP = 5 +const DAY_MS = 24 * 3600 * 1000 + +/** `utcOffset`: the viewer's minutes east of UTC, so days start at their local midnight. */ +export const UsageHistoryQuerySchema = z.object({ + utcOffset: z.coerce.number().int().min(-840).max(840).default(0) +}) + +export type UsageHistoryTop = { + top: Array<{ [key in K]: string } & { seconds: number }> + /** Everyone (or everything) past the top entries, plus segments with no member recorded. */ + otherCount: number + otherSeconds: number +} + +export type UsageHistory = { + /** Oldest first, exactly USAGE_HISTORY_DAYS entries; `start` is the local midnight in epoch ms. */ + days: Array<{ start: number; seconds: number }> + totalSeconds: number + /** The caller's own sandbox hours in the same days. */ + yourSeconds: number + /** Owners and admins only; null for members. */ + members: UsageHistoryTop<'userId'> | null + sandboxes: UsageHistoryTop<'sandboxId'> | null +} + +/** Epoch ms of the local midnight that starts the oldest day shown. */ +export function usageHistoryStart(now: number, utcOffsetMinutes: number): number { + const offset = utcOffsetMinutes * 60_000 + const today = Math.floor((now + offset) / DAY_MS) * DAY_MS - offset + return today - (USAGE_HISTORY_DAYS - 1) * DAY_MS +} + +function topOf( + key: K, + rows: Array<{ id: string | null; seconds: number }> +): UsageHistoryTop { + const named = rows.filter((row) => row.id !== null).sort((a, b) => b.seconds - a.seconds) + const top = named.slice(0, USAGE_HISTORY_TOP) + const rest = [...named.slice(USAGE_HISTORY_TOP), ...rows.filter((row) => row.id === null)] + return { + top: top.map((row) => ({ [key]: row.id, seconds: row.seconds }) as { [k in K]: string } & { seconds: number }), + otherCount: rest.filter((row) => row.id !== null).length, + otherSeconds: rest.reduce((sum, row) => sum + row.seconds, 0) + } +} + +export async function usageHistory( + db: D1Database, + caller: BillingCaller, + now: number, + utcOffsetMinutes: number +): Promise { + const start = usageHistoryStart(now, utcOffsetMinutes) + const range = 'account_id = ?1 AND ended_at >= ?2 AND ended_at <= ?3' + const [byDay, mine, byMember, bySandbox] = await Promise.all([ + db + .prepare( + `SELECT CAST((ended_at - ?2) / ${DAY_MS} AS INTEGER) AS day, SUM(weighted_seconds) AS seconds + FROM usage_events WHERE ${range} GROUP BY day` + ) + .bind(caller.accountId, start, now) + .all<{ day: number; seconds: number }>(), + db + .prepare(`SELECT COALESCE(SUM(weighted_seconds), 0) AS seconds FROM usage_events WHERE ${range} AND user_id = ?4`) + .bind(caller.accountId, start, now, caller.userId) + .first<{ seconds: number }>(), + caller.canManage + ? db + .prepare(`SELECT user_id AS id, SUM(weighted_seconds) AS seconds FROM usage_events WHERE ${range} GROUP BY user_id`) + .bind(caller.accountId, start, now) + .all<{ id: string | null; seconds: number }>() + : null, + caller.canManage + ? db + .prepare(`SELECT sandbox_id AS id, SUM(weighted_seconds) AS seconds FROM usage_events WHERE ${range} GROUP BY sandbox_id`) + .bind(caller.accountId, start, now) + .all<{ id: string; seconds: number }>() + : null + ]) + const days = Array.from({ length: USAGE_HISTORY_DAYS }, (_, index) => ({ start: start + index * DAY_MS, seconds: 0 })) + for (const row of byDay.results) { + const day = days[row.day] + if (day) { + day.seconds += row.seconds + } + } + return { + days, + totalSeconds: days.reduce((sum, day) => sum + day.seconds, 0), + yourSeconds: mine?.seconds ?? 0, + members: byMember ? topOf('userId', byMember.results) : null, + sandboxes: bySandbox ? topOf('sandboxId', bySandbox.results) : null + } +} diff --git a/cloud/apps/billing/src/webhook.ts b/cloud/apps/billing/src/webhook.ts index e4373aecd8a..c2118c32d45 100644 --- a/cloud/apps/billing/src/webhook.ts +++ b/cloud/apps/billing/src/webhook.ts @@ -3,7 +3,8 @@ import type { Env } from './env' import { planForPrice } from './plans' import { allowsLiveMode, type StripeClient, type StripeSubscription } from './stripe' -import { accountForCustomer, claimEvent, customerFor, finishEvent, upsertSubscription } from './store' +import { accountForCustomer, claimEvent, currentSubscription, customerFor, finishEvent, upsertSubscription } from './store' +import { retireOverageItem } from './overage' import { splitSecrets, verifyStripeSignature } from './webhook-signature' const MAX_BODY_BYTES = 512 * 1024 @@ -112,6 +113,15 @@ export async function syncSubscription(env: Env, stripe: StripeClient, subscript // Membership comes from auth, not Stripe: keep the stored count. member_count: null }) + if (overageItemId) { + // An opted-out account's overage item goes once the period it was used in has been invoiced. + const stored = await currentSubscription(db, accountId) + if (stored?.stripe_subscription_id === subscription.id) { + await retireOverageItem(env, stripe, stored, now).catch((error: unknown) => { + console.error(JSON.stringify({ error: 'retire_overage_item', message: error instanceof Error ? error.message.slice(0, 200) : '' })) + }) + } + } } export async function handleStripeWebhook(env: Env, stripe: StripeClient, request: Request, now: number): Promise { diff --git a/cloud/apps/billing/test/overage-opt-out.test.ts b/cloud/apps/billing/test/overage-opt-out.test.ts new file mode 100644 index 00000000000..544550aad18 --- /dev/null +++ b/cloud/apps/billing/test/overage-opt-out.test.ts @@ -0,0 +1,97 @@ +// Opting out of overage: nothing more is metered or billed, and the metered item comes off the +// subscription once nothing on it is left to invoice (no $0 overage line on later invoices). +import { describe, expect, it } from 'vitest' +import { checkoutCompleted, stripeEvent } from './stripe-fake' +import { createHarness } from './harness' + +const HOUR = 3600 +const PERIOD_START = Math.floor(Date.now() / 1000) - 5 * 24 * HOUR +const PERIOD_END = PERIOD_START + 30 * 24 * HOUR + +async function optedInTeam() { + const h = await createHarness() + const token = await h.desktopToken({ sub: 'u1', org: 'o1', orgRole: 'owner', email: 'a@example.com' }) + const auth = { authorization: `Bearer ${token}` } + await h.call('POST', '/v1/billing/checkout', { body: { plan: 'team', seats: 2 }, headers: auth }) + 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' })) + const overage = (body: unknown) => h.call('POST', '/v1/billing/overage', { body, headers: auth }) + expect((await overage({ enabled: true })).status).toBe(200) + const prices = () => subscription.items.data.map((item) => item.price.id) + expect(prices()).toEqual(['price_team_month', 'price_overage']) + let n = 0 + const use = (hours: number) => { + const endedAt = Date.now() - 60_000 + return h.controlPlane('/v1/internal/usage', { + usageId: `u-${n++}`, + accountId: 'org:o1', + sandboxId: 'sbx_1', + machineSize: 'standard', + startedAt: endedAt - hours * HOUR * 1000, + endedAt + }) + } + const stored = () => + h.raw.prepare('SELECT overage_enabled, overage_item_id IS NOT NULL AS has_item FROM subscriptions').get() + return { h, auth, subscription, overage, prices, use, stored } +} + +describe('overage opt-out', () => { + it('removes the unused metered item at once, and opting back in adds it again', async () => { + const { h, overage, prices, use, stored } = await optedInTeam() + expect((await overage({ enabled: false })).status).toBe(200) + expect(prices()).toEqual(['price_team_month']) + expect(stored()).toEqual({ overage_enabled: 0, has_item: 0 }) + // Past the included hours with overage off: nothing is metered. + for (let i = 0; i < 6; i++) { + await use(24) + } + expect(h.stripe.meterEvents).toHaveLength(0) + expect(h.raw.prepare('SELECT COUNT(*) AS n FROM meter_reports').get()).toEqual({ n: 0 }) + expect((await overage({ enabled: true })).status).toBe(200) + expect(prices()).toEqual(['price_team_month', 'price_overage']) + }) + + it('a $0 cap never meters, even with overage on', async () => { + const { h, overage, use } = await optedInTeam() + expect((await overage({ enabled: true, spendCapCents: 0 })).status).toBe(200) + for (let i = 0; i < 6; i++) { + await use(24) + } + expect(h.stripe.meterEvents).toHaveLength(0) + expect(h.raw.prepare('SELECT COUNT(*) AS n FROM meter_reports').get()).toEqual({ n: 0 }) + }) + + it('keeps an item with usage to invoice until the period rolls over, then removes it', async () => { + const { h, overage, prices, use, stored, subscription } = await optedInTeam() + for (let i = 0; i < 5; i++) { + await use(24) + } + await use(2) + expect(h.stripe.meterEvents).toHaveLength(1) + expect((await overage({ enabled: false })).status).toBe(200) + // The 2 overage hours still have to be invoiced on this item. + expect(prices()).toEqual(['price_team_month', 'price_overage']) + await use(3) + expect(h.stripe.meterEvents).toHaveLength(1) + // A sync inside the same period keeps it. + await h.webhook(stripeEvent('customer.subscription.updated', subscription)) + expect(prices()).toEqual(['price_team_month', 'price_overage']) + // Renewal: the next period has nothing metered, so the sync takes the item off. + for (const item of subscription.items.data) { + item.current_period_start = PERIOD_END + item.current_period_end = PERIOD_END + 30 * 24 * HOUR + } + await h.webhook(stripeEvent('customer.subscription.updated', subscription)) + expect(prices()).toEqual(['price_team_month']) + expect(stored()).toEqual({ overage_enabled: 0, has_item: 0 }) + }) +}) diff --git a/cloud/apps/billing/test/usage-history.test.ts b/cloud/apps/billing/test/usage-history.test.ts new file mode 100644 index 00000000000..3c7373d0dc8 --- /dev/null +++ b/cloud/apps/billing/test/usage-history.test.ts @@ -0,0 +1,98 @@ +import { describe, expect, it } from 'vitest' +import { createHarness } from './harness' +import { USAGE_HISTORY_DAYS, usageHistoryStart } from '../src/usage-history' + +const HOUR = 3600 +const DAY_MS = 24 * 3600 * 1000 +// Tokens are checked against the real clock, so the fixture's "now" is real too. +const NOW = Date.now() +const utcMidnight = Math.floor(NOW / DAY_MS) * DAY_MS +// Today's segment, kept inside today even just after midnight. +const END = Math.max(utcMidnight, NOW - 60_000) + +async function seeded() { + const h = await createHarness() + h.setNow(NOW) + const insert = h.raw.prepare( + `INSERT INTO usage_events (usage_id, account_id, sandbox_id, machine_size, started_at, ended_at, weighted_seconds, + period_start, overage_seconds, created_at, user_id) VALUES (?, ?, ?, 'standard', ?, ?, ?, NULL, 0, ?, ?)` + ) + let n = 0 + const add = (endedAt: number, hours: number, sandboxId: string, userId: string | null, account = 'org:o1') => { + insert.run(`u${n++}`, account, sandboxId, endedAt - 60_000, endedAt, hours * HOUR, endedAt, userId) + } + add(END, 2, 'sbx_a', 'alice') + add(END - DAY_MS, 1, 'sbx_b', 'bob') + add(END - 3 * DAY_MS, 3, 'sbx_a', 'alice') + // Six more members, half an hour each: three make the top five, three don't. + for (const user of ['c', 'd', 'e', 'f', 'g', 'h']) { + add(END - 5 * DAY_MS, 0.5, `sbx_${user}`, user) + } + // A segment from before members were recorded. + add(END - 6 * DAY_MS, 0.25, 'sbx_old', null) + // Outside the 30 days, and another team's: never counted. + add(NOW - 31 * DAY_MS, 9, 'sbx_a', 'alice') + add(NOW - DAY_MS, 9, 'sbx_z', 'zed', 'org:o2') + return h +} + +async function read(h: Awaited>, role: string, sub = 'alice', query = '') { + const token = await h.desktopToken({ sub, org: 'o1', orgRole: role }) + return h.call('GET', `/v1/billing/usage${query}`, { headers: { authorization: `Bearer ${token}` } }) +} + +describe('GET /v1/billing/usage', () => { + it('returns 30 local days of team hours and the owner/admin breakdown', async () => { + const h = await seeded() + const { status, body } = await read(h, 'owner') + expect(status).toBe(200) + expect(body.days).toHaveLength(USAGE_HISTORY_DAYS) + expect(body.days.at(-1)).toEqual({ start: utcMidnight, seconds: 2 * HOUR }) + expect(body.days.at(-2).seconds).toBe(1 * HOUR) + expect(body.days.at(-4).seconds).toBe(3 * HOUR) + expect(body.totalSeconds).toBe(9.25 * HOUR) + expect(body.yourSeconds).toBe(5 * HOUR) + expect(body.members.top.map((m: { userId: string }) => m.userId).slice(0, 2)).toEqual(['alice', 'bob']) + expect(body.members.top).toHaveLength(5) + expect(body.members.otherCount).toBe(3) + // Three members past the top five (1.5 hours) plus the unattributed quarter hour. + expect(body.members.otherSeconds).toBe(1.75 * HOUR) + expect(body.sandboxes.top[0]).toEqual({ sandboxId: 'sbx_a', seconds: 5 * HOUR }) + }) + + it('gives members the team chart and their own hours, never the breakdown', async () => { + const h = await seeded() + const { body } = await read(h, 'member', 'bob') + expect(body.totalSeconds).toBe(9.25 * HOUR) + expect(body.yourSeconds).toBe(1 * HOUR) + expect(body.members).toBeNull() + expect(body.sandboxes).toBeNull() + }) + + it('starts days at the viewer’s local midnight', async () => { + const h = await seeded() + const { body } = await read(h, 'admin', 'alice', '?utcOffset=-480') + // In UTC-8 a day starts at 08:00 UTC. + const today = body.days.at(-1).start + expect(new Date(today).getUTCHours()).toBe(8) + expect(today).toBeLessThanOrEqual(NOW) + expect(NOW - today).toBeLessThan(DAY_MS) + expect(body.days[0].start).toBe(usageHistoryStart(NOW, -480)) + }) + + it('rejects a bad offset and an unsigned caller', async () => { + const h = await seeded() + expect((await read(h, 'owner', 'alice', '?utcOffset=9999')).status).toBe(400) + expect((await h.call('GET', '/v1/billing/usage')).status).toBe(401) + }) + + it('returns zeroed days for a team with no usage', async () => { + const h = await createHarness() + h.setNow(NOW) + const token = await h.desktopToken({ sub: 'u1', org: 'o9', orgRole: 'owner' }) + const { body } = await h.call('GET', '/v1/billing/usage', { headers: { authorization: `Bearer ${token}` } }) + expect(body.totalSeconds).toBe(0) + expect(body.days.every((day: { seconds: number }) => day.seconds === 0)).toBe(true) + expect(body.members).toEqual({ top: [], otherCount: 0, otherSeconds: 0 }) + }) +}) diff --git a/cloud/apps/sandbox-control/image/env/environment-build.sh b/cloud/apps/sandbox-control/image/env/environment-build.sh index 24f4f10c053..595ab970c83 100644 --- a/cloud/apps/sandbox-control/image/env/environment-build.sh +++ b/cloud/apps/sandbox-control/image/env/environment-build.sh @@ -5,7 +5,7 @@ # Everything printed here streams live to the desktop build log. # # Env from the control plane (validated there): ORCA_BUILD_REPOS (`||| -# ` lines: each private repo gets its own placeholder the egress swaps), ORCA_INSTALL_SCRIPT_B64, ORCA_LOCKFILES (space list), optional ORCA_GIT_EXTRAHEADER, plus +# ` lines: each private repo gets its own placeholder the egress swaps), ORCA_INSTALL_SCRIPT_B64, ORCA_LOCKFILES (space list), optional ORCA_GIT_EXTRAHEADER and ORCA_CLONE_FILTER, plus # the org secrets the environment names. `::orca-step:: ` lines mark progress. # Exit codes: 10 clone, 20 install script, 30 recording the result. set -uo pipefail @@ -39,7 +39,8 @@ while IFS='|' read -r url branch dir header; do echo "Cloning $url${branch:+ ($branch)}" rm -rf -- "$dest" # The clone's own error shows only when it really failed (an empty repo is recovered below). - if ! git "${git_auth[@]}" clone --quiet ${branch:+--branch "$branch"} -- "$url" "$dest" 2>"$OUT/clone.err"; then + # ORCA_CLONE_FILTER (automatic environments: blob:none) keeps history and trees, not every old blob. + if ! git "${git_auth[@]}" clone --quiet ${ORCA_CLONE_FILTER:+--filter="$ORCA_CLONE_FILTER"} ${branch:+--branch "$branch"} -- "$url" "$dest" 2>"$OUT/clone.err"; then refs=0 git "${git_auth[@]}" ls-remote --exit-code -- "$url" >/dev/null 2>&1 || refs=$? if [ -n "$branch" ] && [ "$refs" -eq 2 ]; then diff --git a/cloud/apps/sandbox-control/image/env/workspace-prelude.sh b/cloud/apps/sandbox-control/image/env/workspace-prelude.sh index 4653e949148..3f8787c7247 100644 --- a/cloud/apps/sandbox-control/image/env/workspace-prelude.sh +++ b/cloud/apps/sandbox-control/image/env/workspace-prelude.sh @@ -68,9 +68,62 @@ clone_failure_reason() { fi } + +# Brings a prebuilt checkout (environment build) up to date: fetches only what changed on the target +# branch (ORCA_REPO_REF, else the build's branch) and checks it out. A branch the remote doesn't have +# yet (a new workspace branch) starts from the build's branch, freshly fetched. Progress goes to stderr. +update_repo() { + local base target status + base="$(git -C "$P" symbolic-ref --quiet --short HEAD 2>/dev/null || true)" + target="${ref:-$base}" + [ -n "$target" ] || return 0 + timeout "$CLONE_TIMEOUT_S" git ${auth[@]+"${auth[@]}"} -C "$P" fetch --progress origin "+refs/heads/$target:refs/remotes/origin/$target" + status=$? + if [ "$status" -eq 0 ]; then + # -f: the install may have rewritten tracked files (a lockfile); the branch's version wins. + git -C "$P" checkout --quiet -f -B "$target" "origin/$target" -- + return $? + fi + [ "$status" -eq 124 ] && return 124 + { [ -n "$base" ] && [ "$base" != "$target" ]; } || return "$status" + timeout "$CLONE_TIMEOUT_S" git ${auth[@]+"${auth[@]}"} -C "$P" fetch --progress origin "+refs/heads/$base:refs/remotes/origin/$base" || return $? + git -C "$P" checkout --quiet -f -B "$target" "origin/$base" -- +} + +# Runs clone_repo or update_repo detached (own session, no inherited stdio), so the start command +# returns while it runs; $CLONE_DIR/state reads running, then done or "failed ". +run_detached() { + echo running >"$CLONE_DIR/state" + : >"$CLONE_DIR/progress.log" + export -f clone_repo update_repo first_commit clone_failure_reason + export P CLONE_DIR CLONE_TIMEOUT_S ORCA_REPO_URL ref + export ORCA_PRELUDE_AUTH="${ORCA_GIT_EXTRAHEADER:-}" ORCA_PRELUDE_STEP="$1" + setsid bash -c ' + auth=() + [ -n "$ORCA_PRELUDE_AUTH" ] && auth=(-c "http.https://github.com/.extraheader=$ORCA_PRELUDE_AUTH") + unset ORCA_PRELUDE_AUTH + "$ORCA_PRELUDE_STEP" >>"$CLONE_DIR/progress.log" 2>&1 + status=$? + if [ "$status" -eq 0 ]; then + echo done >"$CLONE_DIR/state.next" + elif [ "$ORCA_PRELUDE_STEP" = update_repo ]; then + # Not fatal: the build'"'"'s checkout is there, just older. The status says so; the create goes on. + echo "done stale" >"$CLONE_DIR/state.next" + else + echo "failed $(clone_failure_reason "$status" "$CLONE_DIR/progress.log")" >"$CLONE_DIR/state.next" + fi + mv -f "$CLONE_DIR/state.next" "$CLONE_DIR/state" + ' /dev/null 2>&1 & +} + if [ ! -e "$P" ] && [ -n "${ORCA_ENV_REPO_DIR:-}" ] && [ -d "$ROOT/$ORCA_ENV_REPO_DIR/.git" ]; then ln -s "$ROOT/$ORCA_ENV_REPO_DIR" "$P" - if [ -n "$ref" ] && [ "$(git -C "$P" symbolic-ref --quiet --short HEAD 2>/dev/null)" != "$ref" ]; then + if [ "${ORCA_CLONE_BACKGROUND:-}" = 1 ]; then + # The desktop shows this as "Update repository" (GET /v1/sandboxes/:id/clone): fetch what changed + # since the build, in the background. A failure leaves the build's commit, which still opens. + mkdir -p "$CLONE_DIR" + run_detached update_repo + elif [ -n "$ref" ] && [ "$(git -C "$P" symbolic-ref --quiet --short HEAD 2>/dev/null)" != "$ref" ]; then if timeout 60 git "${auth[@]}" -C "$P" fetch --quiet origin "+refs/heads/$ref:refs/remotes/origin/$ref"; then # -f: the install may have rewritten tracked files (a lockfile); the branch's version wins. git -C "$P" checkout --quiet -f -B "$ref" "origin/$ref" -- || @@ -83,25 +136,7 @@ if [ ! -e "$P" ] && [ -n "${ORCA_ENV_REPO_DIR:-}" ] && [ -d "$ROOT/$ORCA_ENV_REP elif [ ! -e "$P" ] && [ -n "${ORCA_REPO_URL:-}" ]; then mkdir -p "$P" "$CLONE_DIR" if [ "${ORCA_CLONE_BACKGROUND:-}" = 1 ]; then - echo running >"$CLONE_DIR/state" - : >"$CLONE_DIR/progress.log" - # Detached (own session, no inherited stdio): the start command returns while this runs. - export -f clone_repo first_commit clone_failure_reason - export P CLONE_DIR CLONE_TIMEOUT_S ORCA_REPO_URL ref - export ORCA_PRELUDE_AUTH="${ORCA_GIT_EXTRAHEADER:-}" - setsid bash -c ' - auth=() - [ -n "$ORCA_PRELUDE_AUTH" ] && auth=(-c "http.https://github.com/.extraheader=$ORCA_PRELUDE_AUTH") - unset ORCA_PRELUDE_AUTH - clone_repo >>"$CLONE_DIR/progress.log" 2>&1 - status=$? - if [ "$status" -eq 0 ]; then - echo done >"$CLONE_DIR/state.next" - else - echo "failed $(clone_failure_reason "$status" "$CLONE_DIR/progress.log")" >"$CLONE_DIR/state.next" - fi - mv -f "$CLONE_DIR/state.next" "$CLONE_DIR/state" - ' /dev/null 2>&1 & + run_detached clone_repo else clone_repo 2>"$CLONE_DIR/progress.log" || exit 1 fi diff --git a/cloud/apps/sandbox-control/image/vm-scripts.generated.ts b/cloud/apps/sandbox-control/image/vm-scripts.generated.ts index 58c4fb576bd..0b9452fc4f3 100644 --- a/cloud/apps/sandbox-control/image/vm-scripts.generated.ts +++ b/cloud/apps/sandbox-control/image/vm-scripts.generated.ts @@ -3,8 +3,8 @@ import type { BuildInputs, GoldenImageManifest } from './golden-image' export const MANIFEST: GoldenImageManifest = {"imageVersion":"2026-11-09.1","image":"vercel/sandbox/node:24","region":"iad1","vcpus":4,"orcad":{"bundleUrl":null,"sha256":null},"gh":{"version":"2.103.3","sha256":"4c806978ffce1cec70853302a56d70ac6da4f19bae7adca4e1a8ab00633dd91d"},"chrome":{"version":"157.0.8103.38-1","sha256":"a62b277dc03da2cff50cc04589deb66f6875be339c066d46adb49b49eedb629d"},"agentCliPackages":["@anthropic-ai/claude-code@2.1.319","@openai/codex@0.166.0","opencode-ai@1.19.5","@google/gemini-cli@0.67.0","@github/copilot@1.0.108"],"cursorAgent":{"version":"2026.11.05-86047df","sha256":"170b77786cbf4c93064d64fff12b71a178b968730561c64afc2e8e752535442e"},"desktop":{"novnc":{"version":"1.6.0","sha256":"5066103959ef4e9b10f37e5a148627360dd8414e4cf8a7db92bdbd022e728aaa"},"websockify":{"version":"0.13.0","sha256":"b6413e364efd04f3c92ec8c17747e3c4adc20157c2ef1c5d019a26d944a46df8"}}} export const PROVISION_SCRIPT: string = "#!/usr/bin/env bash\n# Runs once inside the build sandbox (as the sandbox user, with sudo). Installs the pinned orcad\n# bundle, agent CLIs and Orca's VM entry points into /opt/orca, then smoke-tests orcad.\n# Inputs (env, from image/golden-image.manifest.json via build-golden-image.ts):\n# ORCAD_BUNDLE_URL ORCAD_BUNDLE_SHA256 [GH_VERSION GH_SHA256] [CHROME_VERSION CHROME_SHA256]\n# AGENT_NPM_PACKAGES (space-separated\n# name@version), [CURSOR_AGENT_VERSION CURSOR_AGENT_SHA256], [NOVNC_VERSION NOVNC_SHA256 WEBSOCKIFY_VERSION WEBSOCKIFY_SHA256] and ORCA_VM_SCRIPT_ (base64) for each /opt/orca/bin entry point.\nset -euo pipefail\nORCA_HOME=/opt/orca\nlog() { printf '[golden] %s\\n' \"$*\" >&2; }\n\nsudo mkdir -p \"$ORCA_HOME/bin\" \"$ORCA_HOME/runtime\" \"$ORCA_HOME/tools\"\nsudo chown -R \"$(id -u):$(id -g)\" \"$ORCA_HOME\"\n\nlog 'system packages'\nif command -v apt-get >/dev/null; then\n # Transient mirror errors and dpkg lock contention made apt exit 100 (2 of ~10 golden builds):\n # retry downloads and wait for the lock instead of failing the build.\n printf 'Acquire::Retries \"5\";\\nDPkg::Lock::Timeout \"180\";\\n' | sudo tee /etc/apt/apt.conf.d/80-orca-retries >/dev/null\n # Sandbox egress is TLS-only: plain-http apt mirrors time out at runtime (W2, wake on SSH).\n sudo sed -i 's#http://#https://#g' /etc/apt/sources.list.d/*.sources /etc/apt/sources.list 2>/dev/null || true\n sudo DEBIAN_FRONTEND=noninteractive apt-get update -qq\n # Developer basics agents expect (Conductor parity): rg, tmux, vim, git-lfs alongside the build tools.\n sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends \\\n ca-certificates curl git git-lfs jq ripgrep tmux vim-nox less openssh-client openssh-server build-essential python3 \\\n unzip zip util-linux procps >/dev/null\n git lfs install --system --skip-repo >/dev/null\n # sshd is started on demand by the wake-on-SSH bridge (key-only, loopback); never at boot.\n sudo systemctl disable ssh.service ssh.socket >/dev/null 2>&1 || true\n # A locked password field (\"!\") makes sshd refuse even key logins; '*' = no password, not locked.\n sudo usermod -p '*' \"$(id -un)\"\nelif command -v dnf >/dev/null; then\n sudo dnf install -y -q ca-certificates curl-minimal git git-lfs jq tmux vim-enhanced gcc gcc-c++ make python3 \\\n unzip util-linux procps-ng >/dev/null\nelse\n log 'no supported package manager'; exit 1\nfi\n\n# Managed images have no /vercel/sandbox; the project lives at /vercel/sandbox/project on every image.\nsudo install -d -o \"$(id -u)\" -g \"$(id -g)\" /vercel/sandbox\n\nfetch_verified() { # url sha256 dest\n curl -fsSL --retry 3 -o \"$3\" \"$1\"\n echo \"$2 $3\" | sha256sum -c --quiet -\n}\n\nlog 'orcad bundle'\nbundle=\"$(mktemp -d)/orcad.tgz\"\nfetch_verified \"$ORCAD_BUNDLE_URL\" \"$ORCAD_BUNDLE_SHA256\" \"$bundle\"\ntar -xzf \"$bundle\" -C \"$ORCA_HOME/runtime\"\nrm -rf \"$(dirname \"$bundle\")\"\n# Release tarballs (orca-server-linux-*) may nest the server; normalize to runtime/orcad + runtime/runtimes.\nif [ ! -s \"$ORCA_HOME/runtime/orcad/orcad-server.js\" ]; then\n server=\"$(find \"$ORCA_HOME/runtime\" -name orcad-server.js -type f | head -n 1)\"\n [ -n \"$server\" ] || { log 'bundle has no orcad-server.js'; exit 1; }\n root=\"$(dirname \"$(dirname \"$server\")\")\"\n ln -sfn \"$(dirname \"$server\")\" \"$ORCA_HOME/runtime/orcad\"\n [ -d \"$ORCA_HOME/runtime/runtimes\" ] || ln -sfn \"$root/runtimes\" \"$ORCA_HOME/runtime/runtimes\"\nfi\ntest -s \"$ORCA_HOME/runtime/orcad/orcad-server.js\"\nnode=\"$(find \"$ORCA_HOME/runtime/runtimes\" -type f -name node | head -n 1)\"\ntest -x \"$node\"\n\nif [ -n \"${GH_VERSION:-}\" ]; then\n log \"gh $GH_VERSION\"\n fetch_verified \"https://github.com/cli/cli/releases/download/v${GH_VERSION}/gh_${GH_VERSION}_linux_amd64.tar.gz\" \\\n \"$GH_SHA256\" /tmp/gh.tgz\n tar -xzf /tmp/gh.tgz -C /tmp\n mkdir -p \"$ORCA_HOME/tools/bin\"\n install -m 0755 \"/tmp/gh_${GH_VERSION}_linux_amd64/bin/gh\" \"$ORCA_HOME/tools/bin/gh\"\n rm -rf /tmp/gh.tgz \"/tmp/gh_${GH_VERSION}_linux_amd64\"\nfi\n\nif [ -n \"${CHROME_VERSION:-}\" ] && command -v apt-get >/dev/null; then\n log \"google-chrome $CHROME_VERSION (headless browser for agents and Orca browser automation)\"\n deb=\"$(mktemp -d)/chrome.deb\"\n fetch_verified \"https://dl.google.com/linux/chrome/deb/pool/main/g/google-chrome-stable/google-chrome-stable_${CHROME_VERSION}_amd64.deb\" \\\n \"$CHROME_SHA256\" \"$deb\"\n sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends \"$deb\" >/dev/null\n rm -rf \"$(dirname \"$deb\")\"\n # The .deb adds Google's apt source; the image stays pinned, so drop it.\n sudo rm -f /etc/apt/sources.list.d/google-chrome.list /etc/cron.daily/google-chrome\n google-chrome --headless=new --no-sandbox --disable-gpu --dump-dom 'data:text/html,

ok

' 2>/dev/null | grep -q '

ok

'\nfi\n\nlog 'agent CLIs'\n# The image's system npm installs them; agents later run on whatever node orcad puts on PATH.\n# shellcheck disable=SC2086 # word splitting is the package list\nnpm install --global --no-fund --no-audit --prefix \"$ORCA_HOME/tools\" $AGENT_NPM_PACKAGES\n# opencode-ai installs every linux-x64 build variant (~205 MB each) and hardlinks the one its\n# postinstall picked into bin/opencode.exe, a standalone binary: drop the variants it did not pick.\nopencode_pkg=\"$ORCA_HOME/tools/lib/node_modules/opencode-ai\"\nif [ -x \"$opencode_pkg/bin/opencode.exe\" ]; then\n picked=\"$(stat -c %i \"$opencode_pkg/bin/opencode.exe\")\"\n for variant in \"$opencode_pkg\"/node_modules/opencode-*; do\n [ -d \"$variant\" ] || continue\n [ \"$(stat -c %i \"$variant/bin/opencode\" 2>/dev/null)\" = \"$picked\" ] || rm -rf \"$variant\"\n done\n \"$opencode_pkg/bin/opencode.exe\" --version >/dev/null\nfi\n\n# Copilot CLI prefers GH_TOKEN/GITHUB_TOKEN over the user's own /login. In Orca Cloud those hold the\n# workspace's GitHub App placeholder, which Copilot can't use (\"Resource not accessible by\n# integration\"), so a signed-in user could never get past it. The wrapper drops them for Copilot\n# only (COPILOT_GITHUB_TOKEN, a /login and BYOK still work), unless BYOK is set up, which needs no\n# GitHub sign-in and keeps them so `gh` in Copilot's shell still works.\ncopilot_loader=\"$ORCA_HOME/tools/lib/node_modules/@github/copilot/npm-loader.js\"\nif [ -f \"$copilot_loader\" ]; then\n rm -f \"$ORCA_HOME/tools/bin/copilot\"\n cat >\"$ORCA_HOME/tools/bin/copilot\" </dev/null; fi\ndone\n\nif [ -n \"${CURSOR_AGENT_VERSION:-}\" ]; then\n # Cursor's agent CLI is a pinned tarball (its own node + bundle), not an npm package. The image\n # copy lives under /opt/orca (root-owned) and its release channel is set to \"static\" at boot\n # (orca-sandbox-env), so it never replaces itself mid-session.\n log \"cursor-agent $CURSOR_AGENT_VERSION\"\n tgz=\"$(mktemp -d)/cursor-agent.tgz\"\n fetch_verified \"https://downloads.cursor.com/lab/${CURSOR_AGENT_VERSION}/linux/x64/agent-cli-package.tar.gz\" \\\n \"$CURSOR_AGENT_SHA256\" \"$tgz\"\n rm -rf \"$ORCA_HOME/tools/cursor-agent\"\n mkdir -p \"$ORCA_HOME/tools/cursor-agent\" \"$ORCA_HOME/tools/bin\"\n tar --strip-components=1 -xzf \"$tgz\" -C \"$ORCA_HOME/tools/cursor-agent\"\n rm -rf \"$(dirname \"$tgz\")\"\n ln -sfn ../cursor-agent/cursor-agent \"$ORCA_HOME/tools/bin/cursor-agent\"\n \"$ORCA_HOME/tools/bin/cursor-agent\" --version >/dev/null\nfi\n\nlog 'openssh server (binaries only)'\n# For `orca ssh`: an unprivileged sshd on loopback (see vm/orca-sshd). Only the server binaries,\n# kept out of /usr: the packages would pull in systemd units, SELinux policy (~38 MB on AL2023) and\n# system host keys a user-run sshd never uses. Its libraries are already in the base image, except\n# tcp-wrappers on Ubuntu.\nmkdir -p \"$ORCA_HOME/openssh\"\npkgs=\"$(mktemp -d)\"\nif command -v dnf >/dev/null; then\n sudo dnf install -y -q --setopt=install_weak_deps=False cpio >/dev/null\n sudo dnf install -y -q --downloadonly --downloaddir=\"$pkgs\" openssh-server >/dev/null\n (cd \"$pkgs\" && rpm2cpio openssh-server-[0-9]*.rpm | cpio -idm --quiet)\n sudo dnf clean all -q >/dev/null 2>&1 || true\n libexec=\"$pkgs/usr/libexec/openssh\"\nelse\n sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends libwrap0 >/dev/null\n (cd \"$pkgs\" && apt-get download -qq openssh-server openssh-sftp-server >/dev/null)\n for deb in \"$pkgs\"/*.deb; do dpkg-deb -x \"$deb\" \"$pkgs\"; done\n libexec=\"$pkgs/usr/lib/openssh\"\nfi\ninstall -m 0755 \"$pkgs/usr/sbin/sshd\" \"$libexec/sshd-session\" \"$libexec/sftp-server\" \"$ORCA_HOME/openssh/\"\n# OpenSSH 10 splits authentication into its own binary.\nif [ -x \"$libexec/sshd-auth\" ]; then install -m 0755 \"$libexec/sshd-auth\" \"$ORCA_HOME/openssh/\"; fi\nsudo rm -rf \"$pkgs\"\n\"$ORCA_HOME/openssh/sshd\" -V 2>&1 | head -n 1 >&2 || true\n# sshd refuses a locked account ('!') even for key logins; '*' unlocks it with no usable password.\nsudo usermod -p '*' \"$(id -un)\"\n\ninstall_desktop() {\n # Remote desktop (~80 MB): Xvnc + openbox + xterm from the distro, noVNC + websockify pinned\n # tarballs. Only orca-desktop-start runs it, on demand; nothing starts at boot. Every step says\n # `|| return 1`: errexit does not apply inside an `if` condition.\n command -v apt-get >/dev/null || { log 'remote desktop: apt only'; return 1; }\n sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends \\\n tigervnc-standalone-server tigervnc-tools openbox xterm x11-xserver-utils >/dev/null || return 1\n local tmp dir=\"$ORCA_HOME/desktop\"\n tmp=\"$(mktemp -d)\" || return 1\n fetch_verified \"https://github.com/novnc/noVNC/archive/refs/tags/v${NOVNC_VERSION}.tar.gz\" \\\n \"$NOVNC_SHA256\" \"$tmp/novnc.tgz\" || return 1\n fetch_verified \"https://github.com/novnc/websockify/archive/refs/tags/v${WEBSOCKIFY_VERSION}.tar.gz\" \\\n \"$WEBSOCKIFY_SHA256\" \"$tmp/websockify.tgz\" || return 1\n rm -rf \"$dir\" && mkdir -p \"$dir/novnc\" \"$dir/websockify\" || return 1\n tar -xzf \"$tmp/novnc.tgz\" -C \"$dir/novnc\" --strip-components 1 || return 1\n tar -xzf \"$tmp/websockify.tgz\" -C \"$dir/websockify\" --strip-components 1 || return 1\n # Orca tab fit: title \"Remote desktop\" (Xvnc's -desktop name), no noVNC favicon, control bar on\n # the right (away from Orca's sidebar edge); a stale per-boot password ends the session with one\n # plain message instead of a reconnect loop. \"Unencrypted\" is noVNC's view of plain ws:// to\n # localhost; the hop to the sandbox rides the end-to-end encrypted runtime connection.\n sed -i -e 's/document.title = e.detail.name + \" - \" + PAGE_TITLE;/document.title = e.detail.name;/' \\\n -e \"s/WebUtil.readSetting('controlbar_pos') === 'right'/WebUtil.readSetting('controlbar_pos', 'right') === 'right'/\" \\\n -e 's/securityFailed(e) {/securityFailed(e) { UI.inhibitReconnect = true; UI.showStatus(\"This remote desktop session ended. Reopen it from the workspace menu.\", \"error\"); return;/' \\\n -e 's/_(\"Connected (unencrypted) to \")/_(\"Connected to \")/' \\\n \"$dir/novnc/app/ui.js\" || return 1\n sed -i '/rel=\"icon\"/d; /rel=\"apple-touch-icon\"/d' \"$dir/novnc/vnc.html\" || return 1\n rm -rf \"$tmp\"\n PYTHONPATH=\"$dir/websockify\" python3 -P -c 'import websockify' >/dev/null || return 1\n command -v Xvnc >/dev/null && test -s \"$dir/novnc/vnc.html\"\n}\ndesktop=false\nif [ -n \"${NOVNC_VERSION:-}\" ]; then\n log 'remote desktop'\n # Optional: a failure leaves an image without the desktop, never a failed build.\n if install_desktop; then\n desktop=true\n else\n log 'remote desktop install failed; continuing without it'\n rm -rf \"$ORCA_HOME/desktop\"\n fi\nfi\n\nlog 'Orca entry points'\nfor name in orca-sandbox-start orca-sandbox-drain orca-sandbox-env orca-session-env.sh orca-env orca-egress-probe orca-image-wipe orca-agent-signout orca-share-proxy orca-sshd orca-ssh-keys orca-desktop-start orca-desktop-proxy orca-desktop-page.js orca-sandbox-grant orca-sandbox-revoke orca-sandbox-members orca-sandbox-read-snapshot orca-read-snapshot.cjs orca-git-as orca-git-identity orcad-boot git; do\n var=\"ORCA_VM_SCRIPT_${name//[-.]/_}\"\n printf '%s' \"${!var}\" | base64 -d >\"$ORCA_HOME/bin/$name\"\n chmod 0755 \"$ORCA_HOME/bin/$name\"\ndone\n# The orca CLI (agents drive worktrees, terminals and the browser through it) talks to this VM's orcad.\ncli=\"$(find \"$ORCA_HOME/runtime\" -name orca-cli.cjs -type f | head -n 1)\"\nif [ -n \"$cli\" ]; then\n printf '#!/usr/bin/env bash\\nexport ORCA_USER_DATA_PATH=\"${ORCA_USER_DATA_PATH:-$HOME/.orcad-data}\"\\nexec \"%s\" \"%s\" \"$@\"\\n' \"$node\" \"$cli\" >\"$ORCA_HOME/bin/orca\"\n chmod 0755 \"$ORCA_HOME/bin/orca\"\nelse\n log 'bundle has no orca CLI (orca-cli.cjs): agents will not have `orca` on PATH'\nfi\n# The image's node/npm/npx live only on the build command's PATH; append them so agents (codex's\n# `env node` shebang) and stdio MCP servers launched with npx resolve them in Orca's login shells.\nsystem_node=\"$(command -v npx || command -v node || true)\"\nif [ -z \"$system_node\" ]; then\n echo 'no node/npx on the build PATH' >&2\n exit 1\nfi\nprintf 'export PATH=%s/tools/bin:%s/bin:$PATH:%s\\n' \"$ORCA_HOME\" \"$ORCA_HOME\" \"$(dirname \"$system_node\")\" |\n sudo tee /etc/profile.d/orca.sh >/dev/null\n# Every new shell (login or not: /etc/bashrc sources profile.d) re-reads the session env file.\nsudo install -m 0644 \"$ORCA_HOME/bin/orca-session-env.sh\" /etc/profile.d/zz-orca-session-env.sh\nif [ -f /etc/bash.bashrc ]; then\n # Ubuntu's bash.bashrc does not source profile.d for non-login interactive shells (AL2023's bashrc does).\n grep -q zz-orca-session-env /etc/bash.bashrc ||\n echo '[ -r /etc/profile.d/zz-orca-session-env.sh ] && . /etc/profile.d/zz-orca-session-env.sh' | sudo tee -a /etc/bash.bashrc >/dev/null\nfi\nif [ -f /etc/bash.bashrc ]; then\n # Ubuntu: zsh reads /etc/zsh/zshenv for every shell, so new zsh shells match bash (`orca-env` covers\n # shells that were already open).\n sudo install -d -m 0755 /etc/zsh\n sudo touch /etc/zsh/zshenv\n grep -q zz-orca-session-env /etc/zsh/zshenv ||\n echo '[ -r /etc/profile.d/zz-orca-session-env.sh ] && . /etc/profile.d/zz-orca-session-env.sh' | sudo tee -a /etc/zsh/zshenv >/dev/null\nfi\nsudo chown -R root:root \"$ORCA_HOME\"\n\nlog 'smoke: orcad reaches ready on loopback (and warms the V8 compile cache: ~1.5 s off every boot)'\nsudo install -d -o \"$(id -u)\" -g \"$(id -g)\" \"$ORCA_HOME/compile-cache\"\n# The runtime is root-owned, so its startup-qualified marker lives here. The smoke run leaves one,\n# so every boot from the image skips orcad's disposable startup preflight (~0.6 s of wake).\nsudo install -d -o \"$(id -u)\" -g \"$(id -g)\" \"$ORCA_HOME/startup-qualification\"\nsmoke_data=\"$(mktemp -d)\"\n# orcad-boot also writes orcad's full code cache as the smoke run exits (~0.3 s more off every boot).\nNODE_COMPILE_CACHE=\"$ORCA_HOME/compile-cache\" ORCA_ORCAD_STARTUP_QUALIFICATION_DIR=\"$ORCA_HOME/startup-qualification\" \\\n ORCA_USER_DATA=\"$smoke_data\" timeout 60 \"$node\" \"$ORCA_HOME/bin/orcad-boot\" \\\n --code-cache \"$ORCA_HOME/compile-cache/orcad-server.v8\" --write-code-cache \"$ORCA_HOME/runtime/orcad/orcad-server.js\" \\\n --port 6799 --json >/tmp/orcad-smoke.out 2>/tmp/orcad-smoke.err &\nsmoke_pid=$!\nready=0\nfor _ in $(seq 1 600); do\n if grep -q '\"orca_server_ready\"' /tmp/orcad-smoke.out 2>/dev/null; then ready=1; break; fi\n sleep 0.1\ndone\n# orcad writes the marker just after readiness; best effort, a boot without one only re-qualifies.\nfor _ in $(seq 1 30); do\n [ \"$ready\" = 1 ] && [ ! -s \"$ORCA_HOME/startup-qualification/.orcad-startup-qualified\" ] || break\n sleep 0.1\ndone\nkill \"$smoke_pid\" 2>/dev/null || true\nwait \"$smoke_pid\" 2>/dev/null || true\nrm -rf \"$smoke_data\" /tmp/orcad-smoke.out\nif [ \"$ready\" != 1 ]; then\n tail -n 40 /tmp/orcad-smoke.err >&2; exit 1\nfi\n# Best effort: without it every boot loads orcad as before.\nif [ -s \"$ORCA_HOME/compile-cache/orcad-server.v8\" ]; then\n log \"orcad code cache: $(stat -c %s \"$ORCA_HOME/compile-cache/orcad-server.v8\") bytes\"\nelse\n log 'orcad code cache was not written; boots compile orcad without it'\n grep 'orcad-boot' /tmp/orcad-smoke.err >&2 || true\nfi\n\nlog 'versions'\nversions=\"{}\"\nfor bin in claude codex opencode gemini cursor-agent copilot gh; do\n if [ -x \"$ORCA_HOME/tools/bin/$bin\" ]; then\n v=\"$(\"$ORCA_HOME/tools/bin/$bin\" --version 2>/dev/null | head -n 1 || echo unknown)\"\n versions=\"$(jq -c --arg k \"$bin\" --arg v \"$v\" '. + {($k): $v}' <<<\"$versions\")\"\n fi\ndone\nfor sys in rg vim git-lfs google-chrome; do\n if command -v \"$sys\" >/dev/null; then\n v=\"$(\"$sys\" --version 2>/dev/null | head -n 1 || echo unknown)\"\n versions=\"$(jq -c --arg k \"$sys\" --arg v \"$v\" '. + {($k): $v}' <<<\"$versions\")\"\n fi\ndone\ncommand -v tmux >/dev/null && versions=\"$(jq -c --arg v \"$(tmux -V)\" '. + {tmux: $v}' <<<\"$versions\")\"\n[ -x \"$ORCA_HOME/bin/orca\" ] && versions=\"$(jq -c '. + {orca: \"bundled\"}' <<<\"$versions\")\"\njq -c --arg node \"$(\"$node\" --version)\" --arg disk \"$(df -h / | awk 'NR==2{print $2}')\" \\\n --argjson desktop \"$desktop\" '{node: $node, disk: $disk, tools: ., desktop: $desktop}' <<<\"$versions\"\n" -export const VM_SCRIPT_SOURCES: BuildInputs['vmScripts'] = {"orca-sandbox-start":"#!/usr/bin/env bash\n# Starts orcad for this boot (idempotent) and prints its recipe line:\n# {\"schemaVersion\":1,\"pairingCode\":\"orca://pair?...\",\"projectRoot\":\"/vercel/sandbox/project\"}\n# Env from the control plane: ORCA_SANDBOX_ID, ORCA_PUBLIC_WSS, optional ORCA_REPO_URL/ORCA_REPO_REF,\n# ORCA_GITHUB_PLACEHOLDER, ORCA_SECRET_ENV (`NAME=` lines: org/personal/repo secrets for\n# orcad and its agents), ORCA_SHARE_PROXY_KEY (this session's share-link proxy key, port 6769).\n# Never prints anything else on stdout's last line.\n# With ORCA_READY_VIA=file it prints {\"schemaVersion\":1,\"readyFile\":\"\"} instead and the control\n# plane reads the offer with the files API: the provider keeps command stdout as logs, not files.\n# With ORCA_READY_KEY too (64 hex chars, this call's key; env is not kept) the pointer also carries\n# \"sealedOffer\": \".\", which saves that round trip.\n# Managed env for every process orcad starts: ORCA_IS_CLOUD=1, ORCA_SANDBOX_ID, ORCA_ROOT_PATH,\n# ORCA_WORKTREE_PATH, ORCA_WORKSPACE_PATH, ORCA_WORKSPACE_NAME, ORCA_DEFAULT_BRANCH, ORCA_PORT and the\n# CONDUCTOR_* names imported Conductor scripts read.\nset -euo pipefail\numask 077\nORCA_HOME=/opt/orca\nSTATE=\"$HOME/.orca-sandbox\"\nPROJECT=/vercel/sandbox/project\nmkdir -p \"$STATE\"\n# Only print_ready uses the key; nothing this script starts inherits it.\nready_key=\"${ORCA_READY_KEY:-}\"\nunset ORCA_READY_KEY\n[[ \"$ready_key\" =~ ^[0-9a-f]{64}$ ]] || ready_key=''\nexec 9>\"$STATE/start.lock\"\nflock -w 60 9\n# Background children close fd 9 (`9>&-`): an orcad that inherited it would hold the lock for its whole\n# life and every later start (resume of a running sandbox, a retried create) would wait out the 60 s.\n\n# orcad only lists a project once a client registers it (the desktop does on connect), so API, MCP,\n# routine and phone sessions saw no repo. Register the workspace project at every start, in the\n# background (ready is not delayed); `repo add` of an already-registered path is a no-op error.\nregister_project() {\n [ -x \"$ORCA_HOME/bin/orca\" ] && [ -d \"$PROJECT\" ] || return 0\n local kind=() name=()\n [ -e \"$PROJECT/.git\" ] || kind=(--kind folder)\n # The checkout lives at .../project; name it after the repository (owner/name.git -> name).\n if [ -n \"${ORCA_REPO_URL:-}\" ]; then\n local base=\"${ORCA_REPO_URL%/}\"\n base=\"${base##*/}\"\n base=\"${base%.git}\"\n [ -n \"$base\" ] && name=(--display-name \"$base\")\n fi\n setsid \"$ORCA_HOME/bin/orca\" repo add --path \"$PROJECT\" \"${kind[@]}\" \"${name[@]}\" --json \\\n >\"$STATE/register-project.log\" 2>&1 &- &\n}\n\nprint_ready() {\n if [ \"${ORCA_READY_VIA:-}\" = file ]; then\n local sealed='' iv\n if [ -n \"$ready_key\" ] && command -v openssl >/dev/null; then\n iv=\"$(od -An -N16 -tx1 /dev/urandom | tr -d ' \\n')\"\n # Best effort: without it the control plane reads the file, as before.\n sealed=\"$(tail -n 1 \"$STATE/ready.json\" | openssl enc -aes-256-ctr -K \"$ready_key\" -iv \"$iv\" -nosalt | base64 -w0)\" &&\n sealed=\"$iv.$sealed\" || sealed=''\n fi\n printf '{\"schemaVersion\":1,\"readyFile\":\"%s\"%s}\\n' \"$STATE/ready.json\" \"${sealed:+,\\\"sealedOffer\\\":\\\"$sealed\\\"}\"\n else\n tail -n 1 \"$STATE/ready.json\"\n fi\n}\n# Command stderr is kept by the provider: strip injected values and credential shapes from log tails.\nredact_log() {\n local text kv value\n text=\"$(cat)\"\n for kv in ${agent_env[@]+\"${agent_env[@]}\"}; do\n value=\"${kv#*=}\"\n if [ \"${#value}\" -ge 8 ]; then\n text=\"${text//\"$value\"/[REDACTED]}\"\n fi\n done\n printf '%s\\n' \"$text\" | sed -E \\\n -e 's#orca://[^[:space:]]+#[REDACTED_PAIRING]#g' \\\n -e 's#(gh[pousr]_|github_pat_|sk-|vc[kpiar]_)[A-Za-z0-9._-]{16,}#[REDACTED_TOKEN]#g' \\\n -e 's#eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}#[REDACTED_JWT]#g' \\\n -e 's#(Authorization|authorization):[[:space:]]*[A-Za-z]+[[:space:]]+[^[:space:]]+#\\1: [REDACTED]#g'\n}\n\nnode=\"$(find \"$ORCA_HOME/runtime/runtimes\" -type f -name node | head -n 1)\"\n\n# Share-link proxy (port 6769): answers only requests the control plane signed with this session's\n# key, so its public route is useless on its own. The key goes in on stdin (printf is a builtin), so\n# it never appears in any argv or in the proxy's /proc//environ.\nstart_share_proxy() {\n [ -n \"${ORCA_SHARE_PROXY_KEY:-}\" ] && [ -x \"$ORCA_HOME/bin/orca-share-proxy\" ] || return 0\n if [ \"$(cat \"$STATE/share-proxy.boot\" 2>/dev/null || true)\" = \"$boot_id\" ] \\\n && kill -0 \"$(cat \"$STATE/share-proxy.pid\" 2>/dev/null || echo 0)\" 2>/dev/null; then\n return 0\n fi\n printf '%s' \"$ORCA_SHARE_PROXY_KEY\" | env -i HOME=\"$HOME\" LANG=C.UTF-8 PATH=/usr/bin:/bin \\\n setsid \"$node\" \"$ORCA_HOME/bin/orca-share-proxy\" >\"$STATE/share-proxy.log\" 2>&1 9>&- &\n echo $! >\"$STATE/share-proxy.pid\"\n printf '%s' \"$boot_id\" >\"$STATE/share-proxy.boot\"\n}\n\nboot_id=\"$(cat /proc/sys/kernel/random/boot_id)\"\nstart_share_proxy\nunset ORCA_SHARE_PROXY_KEY\nif [ \"$(cat \"$STATE/boot-id\" 2>/dev/null || true)\" = \"$boot_id\" ] && [ -s \"$STATE/ready.json\" ] \\\n && kill -0 \"$(cat \"$STATE/orcad.pid\" 2>/dev/null || echo 0)\" 2>/dev/null; then\n print_ready\n exit 0\nfi\n# Resume = reboot from disk: locks and pids from the previous session name dead processes.\nrm -f \"$STATE/ready.json\" \"$STATE/orcad.pid\"\nprintf '%s' \"$boot_id\" >\"$STATE/boot-id\"\n\nif [ -n \"${ORCA_GIT_EXTRAHEADER:-}\" ]; then\n # Every github.com request carries the placeholder; the egress policy swaps in a 1h repo token.\n git config --global http.https://github.com/.extraheader \"$ORCA_GIT_EXTRAHEADER\"\nfi\n# Commits outside a teammate's turn (or before any member connected GitHub) need an author too.\ngit config --global user.email >/dev/null 2>&1 || git config --global user.email 'cloud@users.noreply.onorca.dev'\ngit config --global user.name >/dev/null 2>&1 || git config --global user.name 'Orca Cloud'\n# First boot clones while orcad starts (orcad only needs the directory to exist); ready waits for both.\nclone_pid=''\nif [ ! -d \"$PROJECT\" ]; then\n mkdir -p \"$PROJECT\"\n if [ -n \"${ORCA_REPO_URL:-}\" ]; then\n git clone --quiet ${ORCA_REPO_REF:+--branch \"$ORCA_REPO_REF\"} -- \"$ORCA_REPO_URL\" \"$PROJECT\" 2>\"$STATE/clone.log\" 9>&- &\n clone_pid=$!\n fi\nfi\n\n# The clone may still be running here, so the name comes from the URL; the default branch is\n# filled in lazily by the session-env shell hook once the clone exists.\nif [ -n \"${ORCA_REPO_URL:-}\" ]; then\n workspace_name=\"$(basename \"${ORCA_REPO_URL%/}\" .git)\"\nelse\n workspace_name=\"$(basename \"$(git -C \"$PROJECT\" remote get-url origin 2>/dev/null || echo \"$PROJECT\")\" .git)\"\nfi\n# One workspace per VM: its preview ports start at 3000 (Conductor allots CONDUCTOR_PORT..+9).\nmanaged_env=(\n ORCA_IS_CLOUD=1\n ORCA_ROOT_PATH=\"$PROJECT\" ORCA_WORKTREE_PATH=\"$PROJECT\" ORCA_WORKSPACE_PATH=\"$PROJECT\"\n ORCA_WORKSPACE_NAME=\"$workspace_name\" ORCA_PORT=3000\n CONDUCTOR_IS_CLOUD=1\n # Agent CLIs are pinned by the image (smoke-tested); a self-update mid-session can break a running agent.\n DISABLE_AUTOUPDATER=1 OPENCODE_DISABLE_AUTOUPDATE=1 COPILOT_AUTO_UPDATE=false\n CONDUCTOR_ROOT_PATH=\"$PROJECT\" CONDUCTOR_WORKSPACE_PATH=\"$PROJECT\"\n CONDUCTOR_WORKSPACE_NAME=\"$workspace_name\" CONDUCTOR_PORT=3000\n)\n\nagent_env=()\nif command -v google-chrome >/dev/null; then\n # Orca's browser automation and agent browser tools use the image's headless Chrome.\n agent_env+=(\"ORCA_BROWSER_EXECUTABLE=$(command -v google-chrome)\")\nfi\nif [ -n \"${ORCA_GITHUB_PLACEHOLDER:-}\" ]; then\n # The egress layer swaps the placeholder for a short-lived GitHub token; none lives in the VM.\n agent_env+=(\"GH_TOKEN=$ORCA_GITHUB_PLACEHOLDER\" \"GITHUB_TOKEN=$ORCA_GITHUB_PLACEHOLDER\")\nfi\n\nsecret_names=()\nif [ -n \"${ORCA_SECRET_ENV:-}\" ]; then\n # Secrets live only in memory: orcad's process env and a tmpfs file new shells re-read\n # (orca-sandbox-env), never under $HOME or the project, so the stop snapshot never carries them.\n # Resolved per start (and per edit) by the control plane: no image rebuild, no restart.\n while IFS= read -r line; do\n name=\"${line%%=*}\" b64=\"${line#*=}\" # not IFS='=': read would strip base64 padding\n case \"$name\" in '' | *[!A-Z0-9_]* | [0-9]* | ORCA_* | PATH | HOME | LD_* | DYLD_*) continue ;; esac\n agent_env+=(\"$name=$(printf '%s' \"$b64\" | base64 -d)\")\n secret_names+=(\"$name\")\n done < <(printf '%s\\n' \"$ORCA_SECRET_ENV\") # a pipe, not a here-string temp file\nfi\n# Always rewrite the file, so a resume with fewer secrets drops the old names too.\n\"$ORCA_HOME/bin/orca-sandbox-env\" >/dev/null || echo 'session env file unavailable; secrets apply at boot only' >&2\nunset ORCA_SECRET_ENV\n\n# Agent CLIs installed with the image's npm (codex, gemini, ...) are `#!/usr/bin/env node` scripts:\n# terminals need that node on PATH, not only orcad's bundled runtime.\nsystem_node=\"$(command -v node 2>/dev/null || echo \"$node\")\"\n# The egress proxy answers for hosts with credential rules (model APIs, api.github.com) with a\n# certificate from Vercel's CA, which this command's env trusts (Vercel sets these). Pure-Node clients\n# use Node's bundled roots otherwise: Gemini CLI retried forever (\"taking a bit longer\") in every\n# terminal while the same call worked here. Pass the provider's CA settings on to orcad and its shells.\nca_env=(NODE_USE_SYSTEM_CA=\"${NODE_USE_SYSTEM_CA:-1}\")\nfor name in NODE_EXTRA_CA_CERTS SSL_CERT_FILE; do\n if [ -n \"${!name:-}\" ]; then ca_env+=(\"$name=${!name}\"); fi\ndone\nenv -i HOME=\"$HOME\" USER=\"$(id -un)\" LANG=C.UTF-8 TERM=xterm-256color \"${ca_env[@]}\" \\\n PATH=\"$ORCA_HOME/tools/bin:$ORCA_HOME/bin:$(dirname \"$system_node\"):/usr/local/bin:/usr/bin:/bin\" \\\n ORCA_USER_DATA=\"$HOME/.orcad-data\" ORCA_SANDBOX_ID=\"$ORCA_SANDBOX_ID\" \"${managed_env[@]}\" \\\n NODE_COMPILE_CACHE=\"$ORCA_HOME/compile-cache\" ORCA_ORCAD_STARTUP_QUALIFICATION_DIR=\"$ORCA_HOME/startup-qualification\" \\\n ORCA_SESSION_ENV_NAMES=\"${secret_names[*]}\" \"${agent_env[@]}\" \\\n setsid nohup \"$node\" \"$ORCA_HOME/bin/orcad-boot\" --code-cache \"$ORCA_HOME/compile-cache/orcad-server.v8\" \\\n \"$ORCA_HOME/runtime/orcad/orcad-server.js\" --port 6768 --bind 0.0.0.0 --pairing-address \"$ORCA_PUBLIC_WSS\" \\\n --recipe-json --project-root \"$PROJECT\" \\\n >\"$STATE/ready.json\" 2>\"$STATE/orcad.log\" &- &\necho $! >\"$STATE/orcad.pid\"\n\n# sshd for `orca ssh` (loopback only). Best effort: a workspace without it still serves orcad.\n\"$ORCA_HOME/bin/orca-sshd\" >/dev/null 2>\"$STATE/sshd-start.err\" || true\n\n# Polled every 10 ms (at least 60 s in all): ready is on the wake path, so detect it promptly.\nfor _ in $(seq 1 6000); do\n if grep -q '\"pairingCode\"' \"$STATE/ready.json\" 2>/dev/null; then\n if [ -n \"$clone_pid\" ] && ! wait \"$clone_pid\"; then\n echo 'repository clone failed' >&2\n tail -n 5 \"$STATE/clone.log\" | redact_log >&2\n exit 1\n fi\n register_project\n print_ready\n exit 0\n fi\n if ! kill -0 \"$(cat \"$STATE/orcad.pid\")\" 2>/dev/null; then\n echo 'orcad exited before ready' >&2\n tail -n 40 \"$STATE/orcad.log\" | redact_log >&2\n exit 1\n fi\n sleep 0.01\ndone\necho 'orcad start timed out' >&2\nexit 1\n","orca-sandbox-drain":"#!/usr/bin/env bash\n# Asks orcad to quit before the VM stops: its shutdown turns working agent chats into durable\n# restart offers and flushes terminal restore hints, which the desktop continues after resume.\nset -euo pipefail\nSTATE=\"$HOME/.orca-sandbox\"\nWAIT_SECONDS=\"${1:-280}\"\npid=\"$(cat \"$STATE/orcad.pid\" 2>/dev/null || true)\"\nif [ -z \"$pid\" ] || ! kill -0 \"$pid\" 2>/dev/null; then\n exit 0\nfi\nkill -TERM \"$pid\"\nfor _ in $(seq 1 $((WAIT_SECONDS * 10))); do\n if ! kill -0 \"$pid\" 2>/dev/null; then\n rm -f \"$STATE/orcad.pid\" \"$STATE/ready.json\"\n exit 0\n fi\n sleep 0.1\ndone\n# Leave it running: the provider stop ends it, and the drain already had its window.\necho 'orcad still draining at deadline' >&2\nexit 0\n","orca-sandbox-env":"#!/usr/bin/env bash\n# Writes this session's secret env where new shells and agent launches read it (orca-session-env.sh).\n# Input: ORCA_SECRET_ENV (`NAME=` lines) from the control plane, at boot (orca-sandbox-start)\n# and whenever a secret changes (POST /v1/sandboxes/:id/env/refresh). The file lives on tmpfs only:\n# never on the sandbox disk, so the stop snapshot never carries it. Prints {\"names\":N} on success.\n# Also keeps Codex pointed at a configured OpenAI-compatible provider (OPENAI_BASE_URL), since Codex\n# does not read that variable: a managed block in ~/.codex/config.toml naming only the env var.\nset -euo pipefail\numask 077\nHOME=\"${HOME:-$(getent passwd \"$(id -u)\" | cut -d: -f6)}\"\n# ORCA_SESSION_ENV_DIR: tests only (a scratch dir off tmpfs); the control plane never sets it.\ndir=\"${ORCA_SESSION_ENV_DIR:-/dev/shm/orca-env-$(id -u)}\"\nif [ -z \"${ORCA_SESSION_ENV_DIR:-}\" ] && [ \"$(stat -f -c %T /dev/shm 2>/dev/null || true)\" != tmpfs ]; then\n # No memory-only place to keep it: refuse rather than write secrets to disk.\n echo 'no tmpfs for the session env' >&2\n exit 3\nfi\nmkdir -p \"$dir\"\nchmod 700 \"$dir\"\n# Writes are ordered by the control plane's resolve time: an older refresh that lost a race is dropped.\ngeneration=\"${ORCA_ENV_GENERATION:-0}\"\ncase \"$generation\" in '' | *[!0-9]*) generation=0 ;; esac\ncurrent=\"$(cat \"$dir/generation\" 2>/dev/null || echo 0)\"\ncase \"$current\" in '' | *[!0-9]*) current=0 ;; esac\nif [ \"$generation\" -lt \"$current\" ]; then\n printf '{\"stale\":true}\\n'\n exit 0\nfi\ntmp=\"$(mktemp \"$dir/.session.env.XXXXXX\")\"\ncount=0\nopenai_base_url=''\nopenai_model=''\nanthropic_model=''\nanthropic_key_tail=''\ngateway_key=''\ngemini_key=''\ncodex_placeholder=''\nwhile IFS= read -r line; do\n name=\"${line%%=*}\" b64=\"${line#*=}\"\n # Not for shells: the Codex account placeholder becomes ~/.codex/auth.json below.\n if [ \"$name\" = ORCA_CODEX_AUTH_PLACEHOLDER ]; then\n codex_placeholder=\"$(printf '%s' \"$b64\" | base64 -d)\"\n case \"$codex_placeholder\" in *[!A-Za-z0-9._-]*) codex_placeholder='' ;; esac\n fi\n case \"$name\" in '' | *[!A-Z0-9_]* | [0-9]* | ORCA_* | PATH | HOME | LD_* | DYLD_*) continue ;; esac\n # Values stay base64 in the file; the shell hook decodes them.\n printf '%s=%s\\n' \"$name\" \"$b64\" >>\"$tmp\"\n count=$((count + 1))\n case \"$name\" in\n OPENAI_BASE_URL) openai_base_url=\"$(printf '%s' \"$b64\" | base64 -d)\" ;;\n OPENAI_MODEL) openai_model=\"$(printf '%s' \"$b64\" | base64 -d)\" ;;\n ANTHROPIC_MODEL) anthropic_model=\"$(printf '%s' \"$b64\" | base64 -d)\" ;;\n AI_GATEWAY_API_KEY) gateway_key=1 ;;\n GEMINI_API_KEY | GOOGLE_API_KEY) gemini_key=\"${gemini_key:-gemini-api-key}\" ;;\n GOOGLE_GENAI_USE_VERTEXAI) case \"$(printf '%s' \"$b64\" | base64 -d)\" in true | 1) gemini_key=vertex-ai ;; esac ;;\n # Claude Code asks once per key whether to use ANTHROPIC_API_KEY; it remembers the last 20 chars.\n ANTHROPIC_API_KEY) anthropic_key_tail=\"$(printf '%s' \"$b64\" | base64 -d | tail -c 20)\" ;;\n esac\ndone < <(printf '%s\\n' \"${ORCA_SECRET_ENV:-}\")\nmv -f \"$tmp\" \"$dir/session.env\"\nprintf '%s' \"$generation\" >\"$dir/generation\"\n\n# ---- Codex: trust the workspace and use the configured provider (no secret values) ----\nPROJECT=/vercel/sandbox/project\ncodex_config=\"$HOME/.codex/config.toml\"\ntoml_string() { # TOML basic string; the control plane only accepts https URLs and plain model ids\n local value=\"${1//\\\\/\\\\\\\\}\"\n printf '\"%s\"' \"${value//\\\"/\\\\\\\"}\"\n}\nstrip_managed() { # drop the managed blocks and the blank lines written before them (no growth per refresh)\n awk '/^# >>> orca-cloud managed/{skip=1; blank=\"\"} skip{if (/^# <<< orca-cloud managed/) skip=0; next}\n /^[[:space:]]*$/{blank=blank $0 \"\\n\"; next} {printf \"%s\", blank; blank=\"\"; print}' \"$1\"\n}\n# Always managed: an agent launched from the phone or the API has no one to answer Codex's\n# \"trust this folder?\" screen, so the workspace project is trusted up front.\nif true; then\n mkdir -p \"$HOME/.codex\"\n user_part=\"$(mktemp \"$HOME/.codex/.config.XXXXXX\")\"\n if [ -f \"$codex_config\" ]; then strip_managed \"$codex_config\" >\"$user_part\"; fi\n next=\"$(mktemp \"$HOME/.codex/.config.XXXXXX\")\"\n openai_host=\"${openai_base_url#https://}\"\n openai_host=\"${openai_host%%/*}\"\n custom_provider=''\n if [ -n \"$openai_base_url\" ] && [ \"$openai_host\" != api.openai.com ]; then custom_provider=1; fi\n # Top-level keys must precede every table; each is skipped when the user already set it.\n head_keys=\"$(awk '/^\\[/{exit} {print}' \"$user_part\")\"\n has_key() { grep -Eq \"^[[:space:]]*$1[[:space:]]*=\" <<<\"$head_keys\"; }\n {\n printf '# >>> orca-cloud managed (Orca Cloud; edit in Orca settings)\\n'\n # The sandbox is the isolation boundary: Codex's own bwrap sandbox can't start in it (\"Unexpected\n # capabilities\"), and a prompt delivered from the phone or the API has no one to approve commands.\n has_key sandbox_mode || printf 'sandbox_mode = \"danger-full-access\"\\n'\n has_key approval_policy || printf 'approval_policy = \"never\"\\n'\n if [ -n \"$custom_provider\" ]; then\n has_key model_provider || printf 'model_provider = \"orca_cloud\"\\n'\n if [ -n \"$openai_model\" ] && ! has_key model; then\n printf 'model = %s\\n' \"$(toml_string \"$openai_model\")\"\n fi\n elif [ -n \"$codex_placeholder\" ]; then\n has_key model_provider || printf 'model_provider = \"orca_chatgpt\"\\n'\n fi\n printf '# <<< orca-cloud managed\\n'\n cat \"$user_part\"\n if [ -n \"$custom_provider\" ]; then\n printf '\\n# >>> orca-cloud managed provider\\n[model_providers.orca_cloud]\\nname = \"Orca Cloud\"\\n'\n printf 'base_url = %s\\nenv_key = \"OPENAI_API_KEY\"\\nwire_api = \"responses\"\\n' \"$(toml_string \"$openai_base_url\")\"\n printf '# <<< orca-cloud managed\\n'\n elif [ -n \"$codex_placeholder\" ]; then\n # Codex via the Orca account: the ChatGPT backend over HTTPS. Its default Responses WebSocket can't\n # pass the egress proxy, where the placeholder becomes the real token (found live, Codex 0.166).\n printf '\\n# >>> orca-cloud managed provider\\n[model_providers.orca_chatgpt]\\nname = \"OpenAI\"\\n'\n printf 'base_url = \"https://chatgpt.com/backend-api/codex\"\\nwire_api = \"responses\"\\nrequires_openai_auth = true\\nsupports_websockets = false\\n'\n printf '# <<< orca-cloud managed\\n'\n fi\n } >\"$next\"\n if ! grep -qF \"[projects.\\\"$PROJECT\\\"]\" \"$user_part\"; then\n printf '\\n# >>> orca-cloud managed trust\\n[projects.\"%s\"]\\ntrust_level = \"trusted\"\\n# <<< orca-cloud managed\\n' \"$PROJECT\" >>\"$next\"\n fi\n chmod 600 \"$next\"\n mv -f \"$next\" \"$codex_config\"\n rm -f \"$user_part\"\nfi\n# ---- Codex via the person's Orca account (contract D11): a placeholder ChatGPT login, no refresh token.\n# The egress proxy swaps the real access token on chatgpt.com; the real tokens never reach this VM. The\n# marker remembers which placeholder Orca wrote (a clone gets its own), so a login of the person's own\n# (kill-switch fallback, or `codex login` run here) is set aside while the account applies and put back after.\ncodex_auth=\"$HOME/.codex/auth.json\"\ncodex_saved=\"$HOME/.codex/auth.json.orca-saved\"\ncodex_marker=\"$HOME/.codex/.orca-account-placeholder\"\ncodex_ours=''\n# Ours: the marker's placeholder, or any Orca placeholder (all end in `.orca-placeholder`; a real token never does).\nif [ -f \"$codex_auth\" ] && { { [ -f \"$codex_marker\" ] && grep -qF \"\\\"$(cat \"$codex_marker\")\\\"\" \"$codex_auth\"; } || grep -q '\\.orca-placeholder\"' \"$codex_auth\"; }; then\n codex_ours=1\nfi\nif [ -n \"$codex_placeholder\" ]; then\n mkdir -p \"$HOME/.codex\"\n if [ -f \"$codex_auth\" ] && [ -z \"$codex_ours\" ]; then\n # Never overwrite a login already set aside: a second one gets its own name.\n if [ -e \"$codex_saved\" ]; then mv -f \"$codex_auth\" \"$codex_saved.$(date -u +%Y%m%d%H%M%S)\"; else mv -f \"$codex_auth\" \"$codex_saved\"; fi\n fi\n # Marker first: a run cut short after the swap still recognises the file as Orca's.\n printf '%s' \"$codex_placeholder\" >\"$codex_marker\"\n codex_tmp=\"$(mktemp \"$HOME/.codex/.auth.XXXXXX\")\"\n printf '{\\n \"OPENAI_API_KEY\": null,\\n \"tokens\": {\\n \"id_token\": \"%s\",\\n \"access_token\": \"%s\",\\n \"refresh_token\": \"\",\\n \"account_id\": null\\n },\\n \"last_refresh\": \"%s\"\\n}\\n' \\\n \"$codex_placeholder\" \"$codex_placeholder\" \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\" >\"$codex_tmp\"\n chmod 600 \"$codex_tmp\"\n mv -f \"$codex_tmp\" \"$codex_auth\"\nelif [ -f \"$codex_marker\" ] || [ -n \"$codex_ours\" ]; then\n if [ -n \"$codex_ours\" ]; then rm -f \"$codex_auth\"; fi\n rm -f \"$codex_marker\"\n if [ -f \"$codex_saved\" ] && [ ! -f \"$codex_auth\" ]; then mv -f \"$codex_saved\" \"$codex_auth\"; fi\nfi\n# ---- Claude Code, Gemini CLI, Cursor agent, Copilot CLI, OpenCode: first-run screens answered once\n# (Claude: theme picker, folder trust, bypass-mode warning, the \"use this API key?\" question; others:\n# folder trust, auth-method picker, self-update). A prompt delivered from the phone or the API has no one to click\n# through them, and the agent would sit there doing nothing. Merges; never touches credentials.\nnode_bin=\"$(command -v node || find /opt/orca/runtime/runtimes -type f -name node 2>/dev/null | head -n 1)\"\nif [ -n \"$node_bin\" ]; then\n ORCA_PROJECT=\"$PROJECT\" ORCA_KEY_TAIL=\"$anthropic_key_tail\" ORCA_GEMINI_KEY=\"$gemini_key\" \\\n ORCA_GATEWAY_MODEL=\"${gateway_key:+${anthropic_model:-$openai_model}}\" \"$node_bin\" -e '\nconst fs = require(\"fs\"), path = require(\"path\"), os = require(\"os\")\nconst home = os.homedir()\nconst readJson = (file) => { try { const v = JSON.parse(fs.readFileSync(file, \"utf8\")); return v && typeof v === \"object\" && !Array.isArray(v) ? v : {} } catch { return {} } }\nconst write = (file, value) => {\n fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 })\n const tmp = `${file}.orca-${process.pid}`\n fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + \"\\n\", { mode: 0o600 })\n fs.renameSync(tmp, file)\n}\nconst claudeFile = path.join(process.env.CLAUDE_CONFIG_DIR || home, \".claude.json\")\nconst c = readJson(claudeFile)\nconst before = JSON.stringify(c)\nc.hasCompletedOnboarding = true\nc.theme = c.theme || \"dark\"\nc.bypassPermissionsModeAccepted = true\nc.projects = c.projects && typeof c.projects === \"object\" ? c.projects : {}\nconst p = process.env.ORCA_PROJECT\nc.projects[p] = { ...(c.projects[p] || {}), hasTrustDialogAccepted: true, hasCompletedProjectOnboarding: true }\nconst tail = process.env.ORCA_KEY_TAIL\nif (tail) {\n const r = c.customApiKeyResponses && typeof c.customApiKeyResponses === \"object\" ? c.customApiKeyResponses : {}\n const approved = Array.isArray(r.approved) ? r.approved : []\n const rejected = Array.isArray(r.rejected) ? r.rejected.filter((t) => t !== tail) : []\n c.customApiKeyResponses = { ...r, approved: approved.includes(tail) ? approved : [...approved, tail], rejected }\n}\nif (JSON.stringify(c) !== before) write(claudeFile, c)\nconst settingsFile = path.join(home, \".claude\", \"settings.json\")\nconst s = readJson(settingsFile)\nif (s.skipDangerousModePermissionPrompt !== true) write(settingsFile, { ...s, skipDangerousModePermissionPrompt: true })\n\n// Each block below only fills in what is unset and leaves a file it cannot parse alone.\nconst readStrict = (file) => { try { return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, \"utf8\")) : {} } catch { return null } }\nconst isObject = (v) => v !== null && typeof v === \"object\" && !Array.isArray(v)\nconst section = (o, key) => (isObject(o[key]) ? o[key] : (o[key] = {}))\n\n// Gemini CLI: folder trust and the auth-method picker (only when a Gemini key is configured; a\n// Google sign-in picks its own method), no self-update, no usage stats (its host is not on the\n// egress allowlist, so every send would fail).\nconst geminiTrustFile = path.join(home, \".gemini\", \"trustedFolders.json\")\nconst geminiTrust = readStrict(geminiTrustFile)\nif (isObject(geminiTrust) && !geminiTrust[p]) write(geminiTrustFile, { ...geminiTrust, [p]: \"TRUST_FOLDER\" })\nconst geminiSettingsFile = path.join(home, \".gemini\", \"settings.json\")\nconst g = readStrict(geminiSettingsFile)\nif (isObject(g)) {\n const gBefore = JSON.stringify(g)\n const general = section(g, \"general\")\n general.disableAutoUpdate ??= true\n general.disableUpdateNag ??= true\n section(g, \"privacy\").usageStatisticsEnabled ??= false\n // gemini-api-key or vertex-ai (GOOGLE_GENAI_USE_VERTEXAI=true with an API key): headless runs\n // refuse to start without a method (\"Invalid auth method selected\").\n if (process.env.ORCA_GEMINI_KEY) section(section(g, \"security\"), \"auth\").selectedType ??= process.env.ORCA_GEMINI_KEY\n if (JSON.stringify(g) !== gBefore) write(geminiSettingsFile, g)\n}\n\n// Cursor agent: trust the workspace (cursor-agent keys trust by a slug of the path) and pin the\n// release channel to \"static\", which turns off its background self-update.\nconst cursorTrust = path.join(home, \".cursor\", \"projects\", p.replace(/^\\/+/, \"\").replace(/[^A-Za-z0-9]+/g, \"-\"), \".workspace-trusted\")\nif (!fs.existsSync(cursorTrust)) {\n fs.mkdirSync(path.dirname(cursorTrust), { recursive: true, mode: 0o700 })\n fs.writeFileSync(cursorTrust, JSON.stringify({ trustedAt: new Date().toISOString(), workspacePath: p }, null, 2) + \"\\n\", { mode: 0o600 })\n}\nconst cursorConfigFile = path.join(home, \".cursor\", \"cli-config.json\")\nconst cc = readStrict(cursorConfigFile)\nif (isObject(cc) && cc.channel === undefined) write(cursorConfigFile, { version: 1, ...cc, channel: \"static\" })\n\n// GitHub Copilot CLI: trusted folders live in ~/.copilot/config.json, which Copilot prefixes with\n// \"//\" comment lines; keep them.\nconst copilotFile = path.join(home, \".copilot\", \"config.json\")\nlet copilotHead = \"\"\nlet co = {}\ntry {\n const raw = fs.existsSync(copilotFile) ? fs.readFileSync(copilotFile, \"utf8\") : \"\"\n const lines = raw.split(\"\\n\")\n let i = 0\n while (i < lines.length && /^\\s*\\/\\//.test(lines[i])) i++\n copilotHead = lines.slice(0, i).map((l) => l + \"\\n\").join(\"\")\n const body = lines.slice(i).join(\"\\n\").trim()\n co = body ? JSON.parse(body) : {}\n} catch { co = null }\nif (isObject(co)) {\n const folders = Array.isArray(co.trustedFolders) ? co.trustedFolders : []\n if (!folders.includes(p)) {\n fs.mkdirSync(path.dirname(copilotFile), { recursive: true, mode: 0o700 })\n const tmp = `${copilotFile}.orca-${process.pid}`\n fs.writeFileSync(tmp, copilotHead + JSON.stringify({ ...co, trustedFolders: [...folders, p] }, null, 2) + \"\\n\", { mode: 0o600 })\n fs.renameSync(tmp, copilotFile)\n }\n}\n\n// OpenCode: with the AI Gateway preset and a model secret (ANTHROPIC_MODEL, else OPENAI_MODEL), use\n// that model through the gateway unless the user picked one. A ledger remembers what Orca wrote, so a\n// changed model secret updates it and a model the user set is never touched.\nconst ocDir = path.join(home, \".config\", \"opencode\")\nconst ocFile = path.join(ocDir, \"opencode.json\")\nconst ocLedger = path.join(ocDir, \".orca-managed-model\")\nconst managedModel = process.env.ORCA_GATEWAY_MODEL ? `vercel/${process.env.ORCA_GATEWAY_MODEL}` : \"\"\nconst oc = readStrict(ocFile)\nlet jsoncHasModel = false\ntry { jsoncHasModel = /\"model\"\\s*:/.test(fs.readFileSync(path.join(ocDir, \"opencode.jsonc\"), \"utf8\")) } catch {}\nif (isObject(oc) && !jsoncHasModel) {\n let ours = \"\"\n try { ours = fs.readFileSync(ocLedger, \"utf8\").trim() } catch {}\n const userModel = typeof oc.model === \"string\" && oc.model !== ours\n if (!userModel && (oc.model ?? \"\") !== managedModel) {\n const next = { $schema: \"https://opencode.ai/config.json\", ...oc }\n if (managedModel) next.model = managedModel\n else delete next.model\n write(ocFile, next)\n }\n if (!userModel) {\n if (managedModel) fs.writeFileSync(ocLedger, managedModel + \"\\n\", { mode: 0o600 })\n else fs.rmSync(ocLedger, { force: true })\n }\n}\n\n// OpenCode: two built-in providers cannot work in Orca Cloud, and with no other credential OpenCode\n// picks one and fails (\"Authorization header is badly formatted\" / opencode.ai unreachable) instead\n// of showing \"Connect a provider\". GitHub Copilot reads GITHUB_TOKEN, which here is the stand-in for the\n// GitHub App token of the workspace, never a Copilot token; OpenCode Zen needs opencode.ai, which is not on the\n// egress allowlist. Both stay off unless the user connected them in OpenCode itself (auth.json).\nconst ocAuth = readStrict(path.join(process.env.XDG_DATA_HOME || path.join(home, \".local\", \"share\"), \"opencode\", \"auth.json\"))\nconst connected = new Set(isObject(ocAuth) ? Object.keys(ocAuth) : [])\nconst ocDisabledLedger = path.join(ocDir, \".orca-managed-disabled-providers\")\nconst ocNow = readStrict(ocFile)\nif (isObject(ocNow) && !/\"disabled_providers\"\\s*:/.test((() => { try { return fs.readFileSync(path.join(ocDir, \"opencode.jsonc\"), \"utf8\") } catch { return \"\" } })())) {\n let ours = []\n try { ours = fs.readFileSync(ocDisabledLedger, \"utf8\").split(\"\\n\").filter(Boolean) } catch {}\n const userList = (Array.isArray(ocNow.disabled_providers) ? ocNow.disabled_providers : []).filter((id) => typeof id === \"string\" && !ours.includes(id))\n const managed = [\"github-copilot\", \"opencode\"].filter((id) => !connected.has(id) && !userList.includes(id))\n const next = [...userList, ...managed]\n const before = JSON.stringify(ocNow.disabled_providers ?? [])\n if (JSON.stringify(next) !== before) {\n const updated = { $schema: \"https://opencode.ai/config.json\", ...ocNow }\n if (next.length > 0) updated.disabled_providers = next\n else delete updated.disabled_providers\n write(ocFile, updated)\n }\n if (managed.length > 0) fs.writeFileSync(ocDisabledLedger, managed.join(\"\\n\") + \"\\n\", { mode: 0o600 })\n else fs.rmSync(ocDisabledLedger, { force: true })\n}\n' || echo 'agent first-run state not seeded' >&2\nfi\nprintf '{\"names\":%d}\\n' \"$count\"\n","orca-session-env.sh":"# Orca Cloud: sourced by every new bash/zsh (via /etc/profile.d) so terminals and agents started\n# after a secret edit get the current values with no restart. The file is written by\n# /opt/orca/bin/orca-sandbox-env on tmpfs; names it no longer lists are unset. Cloud secrets win\n# over same-named values already in the environment.\n__orca_env_file=\"/dev/shm/orca-env-$(id -u 2>/dev/null)/session.env\"\nif [ -r \"$__orca_env_file\" ]; then\n # $(...) word-splits in both bash and zsh.\n for __orca_n in $(printf '%s' \"${ORCA_SESSION_ENV_NAMES-}\"); do\n unset \"$__orca_n\" 2>/dev/null || true\n done\n __orca_names=''\n while IFS= read -r __orca_line || [ -n \"$__orca_line\" ]; do\n __orca_n=\"${__orca_line%%=*}\"\n case \"$__orca_n\" in '' | *[!A-Z0-9_]* | [0-9]* | ORCA_* | PATH | HOME | LD_* | DYLD_*) continue ;; esac\n export \"$__orca_n=$(printf '%s' \"${__orca_line#*=}\" | base64 -d 2>/dev/null)\"\n __orca_names=\"$__orca_names $__orca_n\"\n done <\"$__orca_env_file\"\n export ORCA_SESSION_ENV_NAMES=\"${__orca_names# }\"\nfi\n# Default branch of the cloud workspace repo, once its first-boot clone exists (computed once per shell tree).\nif [ -n \"${ORCA_WORKSPACE_PATH-}\" ] && [ -z \"${ORCA_DEFAULT_BRANCH-}\" ]; then\n __orca_branch=\"$(git -C \"$ORCA_WORKSPACE_PATH\" symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null || true)\"\n if [ -n \"$__orca_branch\" ]; then\n export ORCA_DEFAULT_BRANCH=\"${__orca_branch#origin/}\" CONDUCTOR_DEFAULT_BRANCH=\"${__orca_branch#origin/}\"\n fi\nfi\nunset __orca_env_file __orca_line __orca_n __orca_names __orca_branch\n","orca-env":"#!/usr/bin/env bash\n# Prints shell lines that bring the current shell up to date with this session's cloud env (secrets\n# saved after the shell started): eval \"$(orca-env)\" or, in fish: orca-env --fish | source\n# Reads /dev/shm/orca-env-/session.env (written by orca-sandbox-env, `NAME=` lines) and\n# prints an export for each name, plus an unset for each name in $ORCA_SESSION_ENV_NAMES that is gone.\n# Never writes a file. Values are single-quoted, so quotes, newlines and $ in them stay literal.\nset -euo pipefail\nfish=''\ncase \"${1-}\" in\n '') ;;\n --fish) fish=1 ;;\n -h | --help)\n printf 'usage: eval \"$(orca-env)\" (fish: orca-env --fish | source)\\n'\n exit 0\n ;;\n *)\n printf 'orca-env: unknown option %s\\n' \"$1\" >&2\n exit 2\n ;;\nesac\n# ORCA_SESSION_ENV_FILE is for tests; secrets can't set ORCA_* names.\nfile=\"${ORCA_SESSION_ENV_FILE:-/dev/shm/orca-env-$(id -u)/session.env}\"\nset -f # names are split below, never globbed\n# Not written yet (or not a cloud VM): nothing to change, like the shell hook.\n[ -r \"$file\" ] || exit 0\n\n# 'it'\\''s' for POSIX shells; fish single quotes escape only \\ and '.\nquote() {\n local v=\"$1\"\n if [ -n \"$fish\" ]; then\n v=\"${v//\\\\/\\\\\\\\}\"\n v=\"${v//\\'/\\\\\\'}\"\n printf \"'%s'\" \"$v\"\n else\n printf \"'%s'\" \"${v//\\'/\\'\\\\\\'\\'}\"\n fi\n}\n\n# The control plane's reserved names and prefixes (cloud/apps/sandbox-control/src/secrets.ts; a test\n# keeps this in sync): a session file never sets what would hijack the shell or Orca's own processes.\nskip_name() {\n case \"$1\" in\n '' | *[!A-Z0-9_]* | [0-9]*) return 0 ;;\n LD_* | DYLD_* | ORCA_* | VERCEL_* | BASH_FUNC_* | GIT_CONFIG*) return 0 ;;\n PATH | HOME | USER | LOGNAME | SHELL | PWD | OLDPWD | LANG | TERM | TMPDIR | IFS | ENV | \\\n BASH_ENV | PS4 | PROMPT_COMMAND | SHELLOPTS | BASHOPTS | NODE_OPTIONS | NODE_PATH | \\\n NODE_EXTRA_CA_CERTS | NODE_TLS_REJECT_UNAUTHORIZED | SSL_CERT_FILE | SSL_CERT_DIR | \\\n CURL_CA_BUNDLE | REQUESTS_CA_BUNDLE | HTTP_PROXY | HTTPS_PROXY | ALL_PROXY | NO_PROXY | \\\n PYTHONPATH | PYTHONSTARTUP | PERL5OPT | RUBYOPT | JAVA_TOOL_OPTIONS | GIT_SSH | \\\n GIT_SSH_COMMAND | GIT_ASKPASS | GIT_EXEC_PATH | GIT_PROXY_COMMAND | SSH_AUTH_SOCK | \\\n GH_TOKEN | GITHUB_TOKEN) return 0 ;;\n # CLAUDE_CODE_OAUTH_TOKEN is reserved for users but set by the control plane itself: only ever the\n # Orca-account placeholder (contract D10), never a stored value.\n esac\n return 1\n}\n\nnames=' '\nwhile IFS= read -r line || [ -n \"$line\" ]; do\n name=\"${line%%=*}\"\n skip_name \"$name\" && continue\n # $(...) drops trailing newlines; the x keeps them.\n value=\"$(printf '%s' \"${line#*=}\" | base64 -d 2>/dev/null; printf x)\"\n value=\"${value%x}\"\n if [ -n \"$fish\" ]; then\n printf 'set -gx %s %s\\n' \"$name\" \"$(quote \"$value\")\"\n else\n printf 'export %s=%s\\n' \"$name\" \"$(quote \"$value\")\"\n fi\n names=\"$names$name \"\ndone <\"$file\"\nfor name in ${ORCA_SESSION_ENV_NAMES-}; do\n skip_name \"$name\" && continue\n case \"$names\" in *\" $name \"*) continue ;; esac\n if [ -n \"$fish\" ]; then\n printf 'set -e %s\\n' \"$name\"\n else\n printf 'unset %s\\n' \"$name\"\n fi\ndone\nnames=\"${names# }\"\nnames=\"${names% }\"\nif [ -n \"$fish\" ]; then\n printf 'set -gx ORCA_SESSION_ENV_NAMES %s\\n' \"$(quote \"$names\")\"\nelse\n printf 'export ORCA_SESSION_ENV_NAMES=%s\\n' \"$(quote \"$names\")\"\nfi\n","orca-egress-probe":"#!/usr/bin/env bash\n# Bounded Node fetch against each credential host. Vercel transform rules have made undici hang on\n# response bodies (no content-length / transfer-encoding); report it instead of letting agents hang.\n# Prints one JSON line: {\"host\":\"api.github.com\",\"status\":\"ok\"|\"egress_framing_hang\"|\"error\"}.\nset -euo pipefail\nnode=\"$(find /opt/orca/runtime/runtimes -type f -name node | head -n 1)\"\nfor host in \"$@\"; do\n \"$node\" -e '\n const host = process.argv[1]\n const timer = setTimeout(() => { console.log(JSON.stringify({ host, status: \"egress_framing_hang\" })); process.exit(0) }, 8000)\n fetch(`https://${host}/`, { headers: { authorization: process.env.ORCA_PROBE_AUTHORIZATION ?? \"\" } })\n .then((r) => r.arrayBuffer())\n .then(() => { clearTimeout(timer); console.log(JSON.stringify({ host, status: \"ok\" })) })\n .catch(() => { clearTimeout(timer); console.log(JSON.stringify({ host, status: \"error\" })) })\n ' \"$host\"\ndone\n","orca-image-wipe":"#!/usr/bin/env bash\n# Runs last before the golden snapshot. Every sandbox cloned from the image must start without an\n# orcad identity, device registry, agent sign-in or shell history (clone-safe identity, risk #1).\nset -euo pipefail\npkill -f orcad-server.js 2>/dev/null || true\nfor path in \\\n \"$HOME/.orcad-data\" \"$HOME/.orca-sandbox\" \"$HOME/.orca-desktop\" \"$HOME/.config/orca\" \"$HOME/.config/orca-dev\" \\\n \"$HOME/.claude\" \"$HOME/.claude.json\" \"$HOME/.codex\" \"$HOME/.config/gh\" \"$HOME/.gemini\" \\\n \"$HOME/.local/share/opencode\" \"$HOME/.config/opencode\" \"$HOME/.cursor\" \"$HOME/.config/cursor\" \\\n \"$HOME/.local/share/cursor-agent\" \"$HOME/.copilot\" \"$HOME/.npm\" \"$HOME/.cache\" \"$HOME/.config/google-chrome\" \"$HOME/.bash_history\" \\\n /vercel/sandbox/project; do\n rm -rf -- \"$path\"\ndone\nsudo rm -rf /tmp/* /var/tmp/* 2>/dev/null || true\nfor leftover in \"$HOME/.orcad-data\" \"$HOME/.claude\" \"$HOME/.codex\" \"$HOME/.config/gh\" \"$HOME/.cursor\" \"$HOME/.copilot\" \"$HOME/.gemini\"; do\n if [ -e \"$leftover\" ]; then\n echo \"identity survived wipe: $leftover\" >&2\n exit 1\n fi\ndone\necho '{\"wiped\":true}'\n","orca-agent-signout":"#!/usr/bin/env bash\n# Signs every agent out on this sandbox before Orca deletes it (A9): each agent's own logout, then\n# its credential files. Covers logins made inside the sandbox (the kill-switch fallback path).\n# Never fails: the sandbox is deleted next whatever happens. Values are never printed.\nset -u\nHOME=\"${HOME:-$(getent passwd \"$(id -u)\" | cut -d: -f6)}\"\nexport PATH=\"/opt/orca/tools/bin:$HOME/.local/bin:$HOME/.npm-global/bin:/usr/local/bin:/usr/bin:/bin:/opt/orca/bin:${PATH:-}\"\nclaude_dir=\"${CLAUDE_CONFIG_DIR:-$HOME/.claude}\"\nclaude_json=\"${CLAUDE_CONFIG_DIR:-$HOME}/.claude.json\"\ncodex_dir=\"${CODEX_HOME:-$HOME/.codex}\"\n\nlogged_out=0\n# Each logout gets a few seconds; a hung CLI must not hold up the delete.\nif command -v claude >/dev/null 2>&1 && timeout 8 claude auth logout /dev/null 2>&1; then\n logged_out=$((logged_out + 1))\nfi\nif command -v codex >/dev/null 2>&1 && timeout 8 codex logout /dev/null 2>&1; then\n logged_out=$((logged_out + 1))\nfi\n\n# The files go whether or not a logout ran: an older CLI, a missing binary or no network leaves them.\nrm -f -- \"$claude_dir\"/.credentials* \"$HOME/.claude\"/.credentials* \"$codex_dir/auth.json\" \"$HOME/.codex/auth.json\" 2>/dev/null\n# Orca-managed Codex homes keep their own auth.json under orcad's data dir.\nif [ -d \"$HOME/.orcad-data\" ]; then\n find \"$HOME/.orcad-data\" -path '*codex*' -type f -name auth.json -delete 2>/dev/null\nfi\n# ~/.claude.json keeps settings Orca wrote (onboarding, trust); only the sign-in fields go.\nnode_bin=\"$(command -v node || find /opt/orca/runtime/runtimes -type f -name node 2>/dev/null | head -n 1)\"\nfor file in \"$claude_json\" \"$HOME/.claude.json\"; do\n [ -f \"$file\" ] || continue\n if [ -n \"$node_bin\" ]; then\n ORCA_FILE=\"$file\" \"$node_bin\" -e '\nconst fs = require(\"fs\")\nconst file = process.env.ORCA_FILE\nlet c\ntry { c = JSON.parse(fs.readFileSync(file, \"utf8\")) } catch { process.exit(2) }\nif (!c || typeof c !== \"object\" || Array.isArray(c)) process.exit(2)\nlet changed = false\nfor (const key of Object.keys(c)) {\n if (/oauth/i.test(key) || key === \"primaryApiKey\") { delete c[key]; changed = true }\n}\nif (changed) {\n const tmp = `${file}.orca-${process.pid}`\n fs.writeFileSync(tmp, JSON.stringify(c, null, 2) + \"\\n\", { mode: 0o600 })\n fs.renameSync(tmp, file)\n}\n' 2>/dev/null || rm -f -- \"$file\"\n else\n # No node to edit it safely: losing Orca's settings beats leaving a sign-in behind.\n rm -f -- \"$file\"\n fi\ndone\n\nleft=0\nfor file in \"$claude_dir\"/.credentials* \"$HOME/.claude\"/.credentials* \"$codex_dir/auth.json\" \"$HOME/.codex/auth.json\"; do\n [ -e \"$file\" ] && left=$((left + 1))\ndone\nprintf '{\"loggedOut\":%d,\"left\":%d}\\n' \"$logged_out\" \"$left\"\n","orca-share-proxy":"#!/usr/bin/env node\n// Share-link proxy for this VM. Listens on 0.0.0.0:6769 (its public *.vercel.run route) and only\n// serves requests the control plane's share gateway signed with this session's key:\n// x-orca-share: v2.....\n// A request must start before `expiresAt` (60s windows); its response or WebSocket is closed at\n// `until` (the link's expiry, at most 30 minutes out), so a revoked or expired link also loses open\n// streams. Signed requests are reverse-proxied to 127.0.0.1:: streaming both ways, no\n// buffering, WebSocket upgrades piped raw. Anything unsigned gets a bare 404.\n// The key arrives on stdin (orca-sandbox-start pipes it), so it is never in this process's\n// environment or argv; ORCA_SHARE_PROXY_KEY in the env is accepted for tests. Optional\n// ORCA_SHARE_PROXY_PORT (default 6769). Plain Node, no dependencies.\n// getBuiltinModule (Node >= 22.3) works whether node loads this extensionless file as CommonJS\n// (in the VM) or as an ES module (under this repo's type:module package, in tests).\nconst crypto = process.getBuiltinModule('node:crypto')\nconst fs = process.getBuiltinModule('node:fs')\nconst http = process.getBuiltinModule('node:http')\nconst net = process.getBuiltinModule('node:net')\n\nconst LISTEN_PORT = Number(process.env.ORCA_SHARE_PROXY_PORT || 6769)\nconst KEY = Buffer.from((process.env.ORCA_SHARE_PROXY_KEY || fs.readFileSync(0, 'utf8')).trim(), 'base64url')\ndelete process.env.ORCA_SHARE_PROXY_KEY\n// Never proxy to the VM's sshd, orcad or this proxy itself.\n// 6080: the remote desktop (VNC behind a password) is for its owner's forward only.\nconst BLOCKED_PORTS = new Set([2222, 6080, 6768, LISTEN_PORT])\nconst MAX_SKEW_SECONDS = 300\nconst MAX_CONNECTION_SECONDS = 3600\nconst HOP_BY_HOP = ['connection', 'keep-alive', 'proxy-connection', 'transfer-encoding', 'te', 'trailer', 'upgrade']\n\nif (KEY.length < 32) {\n console.error('orca-share-proxy: share proxy key missing or short')\n process.exit(2)\n}\n\n/** The target port and close-by time (ms) for a validly signed request, else null. */\nfunction verify(header, nowMs) {\n if (typeof header !== 'string') {\n return null\n }\n const match = /^v2\\.(\\d{1,5})\\.(\\d{1,12})\\.(\\d{1,12})\\.([0-9a-f]{32})\\.([A-Za-z0-9_-]{43})$/.exec(header)\n if (!match) {\n return null\n }\n const now = Math.floor(nowMs / 1000)\n const port = Number(match[1])\n const expiresAt = Number(match[2])\n const until = Number(match[3])\n if (port < 1 || port > 65535 || BLOCKED_PORTS.has(port)) {\n return null\n }\n if (expiresAt < now || expiresAt > now + MAX_SKEW_SECONDS || until <= now || until > now + MAX_CONNECTION_SECONDS) {\n return null\n }\n const signed = header.slice(0, header.lastIndexOf('.'))\n const expected = crypto.createHmac('sha256', KEY).update(signed).digest()\n const given = Buffer.from(match[5], 'base64url')\n return given.length === expected.length && crypto.timingSafeEqual(given, expected) ? { port, untilMs: until * 1000 } : null\n}\n\nfunction upstreamHeaders(raw, port) {\n const headers = { ...raw }\n const connectionTokens = String(raw.connection || '')\n .split(',')\n .map((token) => token.trim().toLowerCase())\n for (const name of [...HOP_BY_HOP, ...connectionTokens, 'x-orca-share']) {\n delete headers[name]\n }\n // Dev servers (Vite, Next) allow localhost hosts by default; the public host rides x-forwarded-host.\n headers.host = `localhost:${port}`\n return headers\n}\n\nfunction refuse(res) {\n res.writeHead(404, { 'content-type': 'text/plain', 'cache-control': 'no-store' })\n res.end('not found')\n}\n\n/** Ends `close` at the grant's deadline; the timer goes away with the connection. */\nfunction deadline(untilMs, close, ...emitters) {\n const timer = setTimeout(close, Math.max(0, untilMs - Date.now()))\n for (const emitter of emitters) {\n emitter.once('close', () => clearTimeout(timer))\n }\n}\n\nconst server = http.createServer((req, res) => {\n const grant = verify(req.headers['x-orca-share'], Date.now())\n if (grant === null) {\n return refuse(res)\n }\n const { port } = grant\n const upstream = http.request(\n { host: '127.0.0.1', port, method: req.method, path: req.url, headers: upstreamHeaders(req.headers, port) },\n (answer) => {\n const headers = { ...answer.headers }\n for (const name of HOP_BY_HOP) {\n delete headers[name]\n }\n // Marks the answer as the app's, so the gateway can tell it from a route with no proxy behind it.\n headers['x-orca-share-proxy'] = '1'\n res.writeHead(answer.statusCode || 502, answer.statusMessage, headers)\n answer.pipe(res)\n }\n )\n deadline(grant.untilMs, () => {\n upstream.destroy()\n res.destroy()\n }, res)\n upstream.on('error', (error) => {\n if (res.headersSent) {\n res.destroy()\n return\n }\n // The gateway renders its own page for this; the code tells it why. Status 200 on purpose: a 5xx\n // from the VM reaches a Worker as Vercel's own 502 with our headers gone (found live).\n res.writeHead(200, { 'content-type': 'text/plain', 'x-orca-share-proxy': '1', 'x-orca-share-error': error.code === 'ECONNREFUSED' ? 'no_listener' : 'upstream_failed' })\n res.end('upstream unavailable')\n })\n req.on('aborted', () => upstream.destroy())\n req.pipe(upstream)\n})\n\nserver.on('upgrade', (req, socket, head) => {\n const grant = verify(req.headers['x-orca-share'], Date.now())\n if (grant === null) {\n socket.end('HTTP/1.1 404 Not Found\\r\\nconnection: close\\r\\ncontent-length: 0\\r\\n\\r\\n')\n return\n }\n const { port } = grant\n const headers = upstreamHeaders(req.headers, port)\n const target = net.connect(port, '127.0.0.1', () => {\n const lines = [`${req.method} ${req.url} HTTP/1.1`, `connection: upgrade`, `upgrade: ${req.headers.upgrade || 'websocket'}`]\n for (const [name, value] of Object.entries(headers)) {\n for (const item of Array.isArray(value) ? value : [value]) {\n lines.push(`${name}: ${item}`)\n }\n }\n target.write(`${lines.join('\\r\\n')}\\r\\n\\r\\n`)\n if (head && head.length > 0) {\n target.write(head)\n }\n socket.pipe(target)\n target.pipe(socket)\n })\n const close = () => {\n socket.destroy()\n target.destroy()\n }\n deadline(grant.untilMs, close, socket)\n target.on('error', () => {\n if (socket.writable) {\n socket.end('HTTP/1.1 200 OK\\r\\nx-orca-share-proxy: 1\\r\\nx-orca-share-error: no_listener\\r\\nconnection: close\\r\\ncontent-length: 0\\r\\n\\r\\n')\n }\n close()\n })\n socket.on('error', close)\n target.on('close', () => socket.destroy())\n socket.on('close', () => target.destroy())\n})\n\nserver.keepAliveTimeout = 65_000\nserver.headersTimeout = 70_000\n// No request timeout: previews can stream (SSE, long polls) until the grant's deadline.\nserver.requestTimeout = 0\nserver.listen(LISTEN_PORT, '0.0.0.0', () => {\n console.log(`orca-share-proxy listening on ${LISTEN_PORT}`)\n})\n","orca-sshd":"#!/usr/bin/env bash\n# Starts this boot's unprivileged sshd on 127.0.0.1:2222 (idempotent). Nothing outside the VM can\n# reach that port: the desktop tunnels to it over orcad's runtime connection (`orca ssh-proxy`).\n# Key-only, single user (the sandbox user), no root. Its host key and authorized_keys live under\n# ~/.orca-sandbox/ssh on the persistent disk, so the host key stays the same across stop/resume;\n# orca-image-wipe removes that directory, so every VM cloned from the golden image makes its own.\n# Prints {\"port\":2222,\"user\":\"\",\"hostKey\":\"ssh-ed25519 AAAA...\"} on success.\nset -euo pipefail\numask 077\nOPENSSH=/opt/orca/openssh\nSSH_DIR=\"$HOME/.orca-sandbox/ssh\"\nPORT=2222\nmkdir -p \"$SSH_DIR\"\nchmod 0700 \"$HOME/.orca-sandbox\" \"$SSH_DIR\"\nexec 8>\"$SSH_DIR/sshd.lock\"\nflock -w 30 8\n\nif [ ! -x \"$OPENSSH/sshd\" ]; then\n echo 'sshd is not installed in this image' >&2\n exit 3\nfi\nif [ ! -s \"$SSH_DIR/ssh_host_ed25519_key\" ]; then\n rm -f \"$SSH_DIR/ssh_host_ed25519_key\" \"$SSH_DIR/ssh_host_ed25519_key.pub\"\n ssh-keygen -q -t ed25519 -N '' -C \"orca-cloud-host\" -f \"$SSH_DIR/ssh_host_ed25519_key\"\nfi\ntouch \"$SSH_DIR/authorized_keys\"\nchmod 0600 \"$SSH_DIR/authorized_keys\"\n\n# Rewritten every start so an image update's settings apply to existing workspaces. PAM stays at\n# its compiled-in default (off): an unprivileged sshd cannot use it, and this build warns on `no`.\ncat >\"$SSH_DIR/sshd_config\" </dev/null || echo 0)\"\n# Resume reboots from disk, so a recorded pid can name a dead process or an unrelated one.\nif ! { kill -0 \"$pid\" 2>/dev/null && grep -q sshd \"/proc/$pid/cmdline\" 2>/dev/null; }; then\n rm -f \"$SSH_DIR/sshd.pid\"\n : >\"$SSH_DIR/sshd.log\"\n \"$OPENSSH/sshd\" -t -f \"$SSH_DIR/sshd_config\"\n \"$OPENSSH/sshd\" -f \"$SSH_DIR/sshd_config\" -E \"$SSH_DIR/sshd.log\"\n for _ in $(seq 1 100); do\n [ -s \"$SSH_DIR/sshd.pid\" ] && break\n sleep 0.02\n done\n [ -s \"$SSH_DIR/sshd.pid\" ] || { echo 'sshd did not start' >&2; tail -n 20 \"$SSH_DIR/sshd.log\" >&2; exit 1; }\nfi\n\nhost_key=\"$(cut -d' ' -f1-2 \"$SSH_DIR/ssh_host_ed25519_key.pub\")\"\nprintf '{\"port\":%s,\"user\":\"%s\",\"hostKey\":\"%s\"}\\n' \"$PORT\" \"$(id -un)\" \"$host_key\"\n","orca-ssh-keys":"#!/usr/bin/env bash\n# `orca-ssh-keys add|remove`: adds or removes one desktop's key in the Orca-managed authorized_keys\n# of this VM's sshd, then makes sure sshd runs. The control plane passes the key in\n# ORCA_SSH_PUBLIC_KEY (`ssh-ed25519 `), never on the command line. Keys are\n# matched by their base64 blob, so a renamed comment cannot keep a revoked key alive.\n# Prints orca-sshd's {\"port\":...,\"user\":...,\"hostKey\":...} line on success.\nset -euo pipefail\numask 077\nSSH_DIR=\"$HOME/.orca-sandbox/ssh\"\naction=\"${1:-}\"\nkey=\"${ORCA_SSH_PUBLIC_KEY:-}\"\n# grep matches per line: a second line could carry key options past the check below.\ncase \"$key\" in *$'\\n'* | *$'\\r'*) echo 'invalid public key' >&2; exit 2 ;; esac\n# One line, ed25519 only, a plain comment: nothing that sshd would read as key options.\nif ! printf '%s' \"$key\" | grep -Eq '^ssh-ed25519 [A-Za-z0-9+/]{68} [A-Za-z0-9@._:+-]{1,200}$'; then\n echo 'invalid public key' >&2\n exit 2\nfi\nblob=\"$(printf '%s' \"$key\" | cut -d' ' -f2)\"\nmkdir -p \"$SSH_DIR\"\nchmod 0700 \"$HOME/.orca-sandbox\" \"$SSH_DIR\"\nexec 7>\"$SSH_DIR/keys.lock\"\nflock -w 30 7\ntouch \"$SSH_DIR/authorized_keys\"\nnext=\"$(mktemp \"$SSH_DIR/authorized_keys.XXXXXX\")\"\n# Drop the key wherever it appears (with or without options), then append it on add.\nawk -v blob=\"$blob\" '{ for (i = 1; i <= NF; i++) if ($i == blob) next; print }' \\\n \"$SSH_DIR/authorized_keys\" >\"$next\"\ncase \"$action\" in\n add) printf '%s\\n' \"$key\" >>\"$next\" ;;\n remove) ;;\n *) rm -f \"$next\"; echo 'usage: orca-ssh-keys add|remove' >&2; exit 2 ;;\nesac\nchmod 0600 \"$next\"\nmv -f \"$next\" \"$SSH_DIR/authorized_keys\"\nexec /opt/orca/bin/orca-sshd\n","orca-desktop-start":"#!/usr/bin/env bash\n# Starts the on-demand remote desktop (idempotent) and mints one connection ticket. Prints one line:\n# {\"schemaVersion\":2,\"port\":6080,\"display\":\":1\",\"path\":\"vnc.html\",\"ticket\":\"<43 chars>\",\"expiresInMs\":60000}\n# Xvnc (X server + VNC in one) listens on a 0600 unix socket only, with no VNC auth: only this uid\n# can open it. orca-desktop-proxy (websockify + a ticket gate) serves noVNC on 127.0.0.1 and\n# bridges WebSockets to that socket. Nothing is reachable from outside the VM: the desktop app\n# reaches it through Orca's port forward, a localhost port on the user's computer that any local\n# process or web page can reach, so each WebSocket needs a ticket from here: 32 random bytes,\n# single use, valid for 60 s, stored only as its sha256 (the file name; its content is the expiry).\n# The ticket goes to stdout only (the control plane hands it to the desktop app). Never started at boot.\nset -euo pipefail\numask 077\nDESKTOP=/opt/orca/desktop\nSTATE=\"$HOME/.orca-desktop\"\nPORT=\"${ORCA_DESKTOP_PORT:-6080}\"\nDISPLAY_NUM=\"${ORCA_DESKTOP_DISPLAY:-1}\"\nGEOMETRY=\"${ORCA_DESKTOP_GEOMETRY:-1280x800}\"\nSOCKET=\"$STATE/vnc.sock\"\n# The parent's DISPLAY must not leak into the WM/xterm below; they use ours.\nexport DISPLAY=\":$DISPLAY_NUM\"\n\n# Exit 3 = this image has no desktop (built before it, or its optional install failed).\nfail() { printf 'orca-desktop: %s\\n' \"$1\" >&2; exit \"${2:-1}\"; }\ncase \"$PORT\" in '' | *[!0-9]*) fail 'ORCA_DESKTOP_PORT must be a number' ;; esac\ncase \"$DISPLAY_NUM\" in '' | *[!0-9]*) fail 'ORCA_DESKTOP_DISPLAY must be a number' ;; esac\ncase \"$GEOMETRY\" in [0-9]*x[0-9]*) ;; *) fail 'ORCA_DESKTOP_GEOMETRY must look like 1280x800' ;; esac\ncommand -v Xvnc >/dev/null || fail 'not installed in this image (Xvnc missing)' 3\n[ -s \"$DESKTOP/novnc/vnc.html\" ] || fail 'not installed in this image (noVNC missing)' 3\nPROXY=\"$(dirname \"$(readlink -f \"$0\")\")/orca-desktop-proxy\"\n[ -x \"$PROXY\" ] || fail 'orca-desktop-proxy missing next to this script'\nTICKETS=\"$STATE/tickets\"\nTICKET_TTL_S=60\n# Xvnc's mode: a previous version of this script ran it with VncAuth; restart it in this mode.\nMODE=ticket-v1\n\nmkdir -p \"$STATE\"\nexec 9>\"$STATE/start.lock\"\nflock -w 30 9 || fail 'another start is in progress'\n\npid_of() { # never \"0\": kill 0 targets our own process group\n local pid\n pid=\"$(cat \"$STATE/$1.pid\" 2>/dev/null || true)\"\n case \"$pid\" in '' | 0 | *[!0-9]*) return 1 ;; esac\n printf '%s' \"$pid\"\n}\nalive() { local pid; pid=\"$(pid_of \"$1\")\" && kill -0 \"$pid\" 2>/dev/null; }\nmint_ticket() { # prints the ticket; stores only its sha256, with the expiry as content\n local ticket now digest\n mkdir -p \"$TICKETS\"\n now=\"$(date +%s)\"\n # Expired or spent-but-unswept tickets; keep at most 16 live ones (oldest go first).\n for file in \"$TICKETS\"/*; do\n [ -f \"$file\" ] || continue\n [ \"$(cat \"$file\" 2>/dev/null || echo 0)\" -ge \"$now\" ] 2>/dev/null || rm -f \"$file\"\n done\n # shellcheck disable=SC2012 # names are hex digests\n ls -1t \"$TICKETS\" 2>/dev/null | tail -n +16 | while read -r old; do rm -f \"$TICKETS/$old\"; done\n ticket=\"$(head -c 32 /dev/urandom | base64 | tr '+/' '-_' | tr -d '=\\n')\"\n [ \"${#ticket}\" = 43 ] || fail 'could not generate a ticket'\n digest=\"$(printf '%s' \"$ticket\" | sha256sum | cut -d' ' -f1)\"\n printf '%s' \"$((now + TICKET_TTL_S))\" >\"$TICKETS/.$digest\" && mv \"$TICKETS/.$digest\" \"$TICKETS/$digest\"\n printf '%s' \"$ticket\"\n}\nready_line() {\n local ticket\n ticket=\"$(mint_ticket)\" || exit 1\n printf '{\"schemaVersion\":2,\"port\":%s,\"display\":\":%s\",\"path\":\"vnc.html\",\"ticket\":\"%s\",\"expiresInMs\":%s}\\n' \\\n \"$PORT\" \"$DISPLAY_NUM\" \"$ticket\" \"$((TICKET_TTL_S * 1000))\"\n}\nlistening() { # the proxy answers HTTP on loopback\n curl -fsS -o /dev/null --max-time 1 \"http://127.0.0.1:$PORT/vnc.html\" 2>/dev/null\n}\n\n# Pids from a previous boot (resume = reboot from disk) name dead or unrelated processes.\nboot_id=\"$(cat /proc/sys/kernel/random/boot_id)\"\nif [ \"$(cat \"$STATE/boot-id\" 2>/dev/null || true)\" != \"$boot_id\" ]; then\n rm -rf \"$STATE\"/*.pid \"$SOCKET\" \"$STATE/password\" \"$STATE/passwd\" \"$STATE/mode\" \"$TICKETS\"\n printf '%s' \"$boot_id\" >\"$STATE/boot-id\"\nfi\n\n# Same boot, older script: its websockify had no ticket gate and its Xvnc wanted a VNC password.\nrm -f \"$STATE/password\" \"$STATE/passwd\"\nif alive websockify; then kill \"$(pid_of websockify)\" 2>/dev/null || true; fi\nrm -f \"$STATE/websockify.pid\"\ncurrent_mode() { cat \"$STATE/mode\" 2>/dev/null || true; }\n\nif alive xvnc && alive proxy && listening && [ \"$(current_mode)\" = \"$MODE\" ]; then\n ready_line\n exit 0\nfi\n\nstart() { # name cmd... — detached, logs in $STATE/.log\n local name=$1; shift\n # 9>&-: children must not inherit the start lock, or the next call waits for them to exit.\n setsid nohup \"$@\" >\"$STATE/$name.log\" 2>&1 &- &\n echo $! >\"$STATE/$name.pid\"\n}\n\nif ! alive xvnc || [ \"$(current_mode)\" != \"$MODE\" ]; then\n if alive xvnc; then kill \"$(pid_of xvnc)\" 2>/dev/null || true; sleep 0.2; fi\n rm -f \"$SOCKET\"\n # -rfbport -1: no TCP VNC port at all, only a 0600 unix socket (in the 0700 state dir) for the\n # proxy. SecurityTypes None is safe only because of that: the ticket gate is in the proxy.\n # SendPrimary=0: only explicit copies (xterm copies its selection, below) leave the sandbox.\n # The X display itself takes a cookie from ~/.Xauthority (Xlib's default for this user), so only\n # this uid's processes (agents, apps they start on DISPLAY=:1) can open it.\n auth=()\n if command -v xauth >/dev/null && command -v mcookie >/dev/null; then\n xauth -q -f \"$HOME/.Xauthority\" add \":$DISPLAY_NUM\" . \"$(mcookie)\" 9>&- && auth=(-auth \"$HOME/.Xauthority\")\n fi\n start xvnc Xvnc \":$DISPLAY_NUM\" \"${auth[@]}\" -geometry \"$GEOMETRY\" -depth 24 -nolisten tcp \\\n -rfbport -1 -rfbunixpath \"$SOCKET\" -rfbunixmode 0600 \\\n -SecurityTypes None -SendPrimary=0 \\\n -AlwaysShared -AcceptSetDesktopSize -desktop 'Remote desktop'\n printf '%s' \"$MODE\" >\"$STATE/mode\"\n for _ in $(seq 1 100); do\n [ -S \"$SOCKET\" ] && break\n alive xvnc || { tail -n 20 \"$STATE/xvnc.log\" >&2; fail 'Xvnc exited'; }\n sleep 0.05\n done\n [ -S \"$SOCKET\" ] || fail 'Xvnc did not create its socket'\n if command -v xsetroot >/dev/null; then xsetroot -solid '#1e1f22' 9>&- || true; fi\n if command -v openbox >/dev/null; then\n # Dark, flat theme to match Orca; the first terminal stays maximized as the tab resizes the screen.\n printf '%s\\n' '' \\\n 'Onyx' \\\n 'yes' \\\n '' >\"$STATE/openbox.xml\"\n start wm openbox --config-file \"$STATE/openbox.xml\"\n # Let it manage the screen before the terminal maps, so its maximize rule applies.\n sleep 0.2\n elif command -v twm >/dev/null; then\n start wm twm\n fi\n if command -v xterm >/dev/null; then\n # selectToClipboard: a selection is a copy (to CLIPBOARD, which reaches this computer).\n start xterm xterm -maximized -bg '#1e1f22' -fg '#d4d4d4' -fa 'Liberation Mono,Monospace' -fs 11 \\\n -xrm 'XTerm*selectToClipboard: true'\n fi\nfi\n\nif ! alive proxy || ! listening; then\n if alive proxy; then kill \"$(pid_of proxy)\" 2>/dev/null || true; sleep 0.1; fi\n mkdir -p \"$TICKETS\"\n PYTHONPATH=\"$DESKTOP/websockify\" start proxy python3 -P -W ignore::UserWarning \"$PROXY\" \\\n --listen \"$PORT\" --web \"$DESKTOP/novnc\" --unix-target \"$SOCKET\" --tickets \"$TICKETS\"\n for _ in $(seq 1 100); do\n listening && break\n alive proxy || { tail -n 20 \"$STATE/proxy.log\" >&2; fail 'orca-desktop-proxy exited'; }\n sleep 0.05\n done\n listening || fail \"orca-desktop-proxy is not answering on 127.0.0.1:$PORT\"\nfi\nready_line\n","orca-desktop-proxy":"#!/usr/bin/env python3\n# Remote desktop gateway, started by orca-desktop-start: serves noVNC on 127.0.0.1 and bridges one\n# WebSocket per single-use ticket to Xvnc's 0600 unix socket (Xvnc itself has no VNC auth: only this\n# uid can open the socket). The port is reached only through Orca's localhost forward on the user's\n# computer, where any local process or web page could knock, so every WebSocket must carry an\n# unused, unexpired ticket minted by orca-desktop-start (see consume_ticket), from a page on the same\n# localhost origin. Tickets never reach a log: paths are scrubbed before websockify logs them.\n# orca-desktop-proxy --listen PORT --web DIR --unix-target SOCKET --tickets DIR\n# stdlib + websockify (pinned tarball in /opt/orca/desktop/websockify, on PYTHONPATH) only.\nimport argparse\nimport hashlib\nimport hmac\nimport logging\nimport os\nimport re\nimport sys\nimport time\nfrom urllib.parse import parse_qs, urlsplit\n\nfrom websockify import websocketproxy\n\nTICKET_RE = re.compile(r'^[A-Za-z0-9_-]{43}$') # 32 random bytes, base64url without padding\nSCRUB_RE = re.compile(r'([?&]ticket=)[^&\\s\\'\"]*')\nLOOPBACK_HOST_RE = re.compile(r'^(localhost|127\\.0\\.0\\.1|\\[::1\\])(:[0-9]{1,5})?$')\nWS_PATH = '/websockify'\nPAGE_SCRIPT = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'orca-desktop-page.js')\n# The page may only talk to its own origin (its WebSocket included): even a URL that tries to point\n# noVNC elsewhere cannot carry a ticket or the user's keys off this forward.\nPAGE_CSP = \"connect-src 'self'; object-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'self'\"\nPAGE_TAG = b'\\n'\n\n\ndef scrub(text):\n return SCRUB_RE.sub(r'\\1', str(text))\n\n\ndef ticket_digest(ticket):\n return hashlib.sha256(ticket.encode('ascii')).hexdigest()\n\n\ndef consume_ticket(directory, ticket, now=None):\n \"\"\"True once per minted ticket, within its lifetime. The ticket file (named by the ticket's\n sha256, holding its expiry) is unlinked on first use, so a replay or a racing second\n connection finds nothing; each request runs in its own forked process, so state is on disk.\"\"\"\n if not isinstance(ticket, str) or not TICKET_RE.match(ticket):\n return False\n digest = ticket_digest(ticket)\n match = None\n try:\n names = os.listdir(directory)\n except OSError:\n return False\n for name in names:\n # Compare every entry in constant time; never short-circuit on a prefix.\n if hmac.compare_digest(name.encode('ascii', 'replace'), digest.encode('ascii')):\n match = name\n if match is None:\n return False\n path = os.path.join(directory, match)\n try:\n with open(path, 'r', encoding='ascii') as handle:\n expires_at = int(handle.read().strip() or '0')\n except (OSError, ValueError):\n expires_at = 0\n try:\n os.unlink(path) # the consume: only one caller can win this\n except FileNotFoundError:\n return False\n return (now if now is not None else time.time()) <= expires_at\n\n\ndef same_loopback_origin(headers):\n \"\"\"The page and the WebSocket share one localhost origin (blocks other local sites and DNS\n rebinding). The port is the user's local forward, which may differ from ours, so compare the\n Origin with the Host the browser dialed rather than with a fixed port.\"\"\"\n host = (headers.get('Host') or '').strip().lower()\n origin = (headers.get('Origin') or '').strip().lower()\n return loopback_host(host) and origin == 'http://' + host\n\n\ndef loopback_host(host):\n return bool(LOOPBACK_HOST_RE.match(host or ''))\n\n\nclass TicketedProxyHandler(websocketproxy.ProxyRequestHandler):\n \"\"\"websockify's proxy handler plus the ticket + origin gate. Module level (not a closure) so\n websockify's per-connection multiprocessing can pickle it under any start method.\"\"\"\n\n def log_message(self, format, *args): # noqa: A002 (websockify's signature)\n super().log_message('%s', scrub(format % args if args else format))\n\n def reject(self, code, reason):\n self.send_response(code)\n self.send_header('Content-Length', '0')\n self.send_header('Connection', 'close')\n self.end_headers()\n self.close_connection = True\n raise self.server.EClose('desktop: websocket refused (%s)' % reason)\n\n def validate_connection(self):\n parts = urlsplit(self.path)\n ticket = (parse_qs(parts.query).get('ticket') or [''])[0]\n # Drop it before anything below (websockify's own logging included) can see self.path.\n self.path = parts.path\n if parts.path != WS_PATH:\n self.reject(404, 'path')\n if not same_loopback_origin(self.headers):\n self.reject(403, 'origin')\n if not consume_ticket(self.server.orca_tickets_dir, ticket):\n self.reject(403, 'ticket')\n\n def loopback_request(self):\n if loopback_host((self.headers.get('Host') or '').strip().lower()):\n return True\n self.send_error(403)\n return False\n\n def do_GET(self):\n if not self.loopback_request():\n return None\n path = urlsplit(self.path).path\n if path == '/orca-desktop-page.js':\n return self.send_bytes(read_file(PAGE_SCRIPT), 'text/javascript; charset=utf-8')\n if path == '/vnc.html':\n page = read_file(os.path.join(self.server.web, 'vnc.html'))\n return self.send_bytes(page.replace(b'', PAGE_TAG, 1), 'text/html; charset=utf-8', PAGE_CSP)\n return super().do_GET()\n\n def do_HEAD(self):\n if not self.loopback_request():\n return None\n return super().do_HEAD()\n\n def send_bytes(self, body, content_type, csp=None):\n self.send_response(200)\n self.send_header('Content-Type', content_type)\n if csp:\n self.send_header('Content-Security-Policy', csp)\n self.send_header('Content-Length', str(len(body)))\n self.send_header('Cache-Control', 'no-store')\n self.send_header('Referrer-Policy', 'no-referrer')\n self.end_headers()\n self.wfile.write(body)\n return None\n\n\ndef read_file(path):\n with open(path, 'rb') as handle:\n return handle.read()\n\n\ndef main(argv):\n parser = argparse.ArgumentParser()\n parser.add_argument('--listen', type=int, required=True)\n parser.add_argument('--web', required=True)\n parser.add_argument('--unix-target', required=True)\n parser.add_argument('--tickets', required=True)\n args = parser.parse_args(argv)\n logging.basicConfig(level=logging.INFO, format='%(message)s')\n server = websocketproxy.WebSocketProxy(\n RequestHandlerClass=TicketedProxyHandler,\n listen_host='127.0.0.1',\n listen_port=args.listen,\n web=args.web,\n file_only=True,\n unix_target=args.unix_target,\n )\n server.orca_tickets_dir = os.path.abspath(args.tickets)\n server.start_server()\n\n\nif __name__ == '__main__':\n main(sys.argv[1:])\n","orca-desktop-page.js":"// Orca's glue for noVNC, injected into vnc.html by orca-desktop-proxy. Orca (the desktop app's\n// main process) drives it through window.orcaDesktop:\n// - tickets: the page never connects by itself. Each WebSocket needs a fresh single-use ticket,\n// which Orca hands over with connect(ticket) after nextTicketRequest() resolves: 'ticket' on\n// load or after a session dropped, 'retry' after an attempt that never connected. Tickets live\n// only in memory here: never in the URL, storage or noVNC's settings.\n// - pause(message, label): Orca stopped retrying; show why, with a Reconnect button. resume()\n// (Orca reopened the desktop) or the button asks for a ticket again.\n// - fit: resize=remote makes Xvnc follow the tab; a server without SetDesktopSize gets scaling.\n// - clipboard: a copy inside the desktop right after user input there goes to this computer's\n// clipboard; paste(text, chord) sets the sandbox's clipboard first, then replays the paste key.\nimport UI from './app/ui.js';\nimport * as WebUtil from './app/webutil.js';\n\nconst WS_PATH = 'websockify';\nconst RESIZE_FALLBACK_MS = 1500;\n// A copy inside the desktop follows a copy key or a selection (drag or double-click) there; other\n// clipboard changes (an agent in the sandbox running xclip) must not overwrite this computer's\n// clipboard. Plain typing does not open the window.\nconst USER_COPY_WINDOW_MS = 1500;\nconst DRAG_PX = 4;\nconst MAX_CLIPBOARD_CHARS = 1 << 20;\nconst TICKET_RE = /^[A-Za-z0-9_-]{43}$/;\nconst XK = { v: 0x0076, V: 0x0056, Insert: 0xff63, Shift_L: 0xffe1, Super_L: 0xffeb, Super_R: 0xffec };\n\nlet state = 'idle'; // idle | connecting | connected | disconnected | paused\nlet attemptConnected = true;\nlet ticketWaiters = [];\nlet lastCopyIntent = 0;\nlet pointerStart = null;\n\nconst style = document.createElement('style');\n// Orca owns connecting and the chrome: noVNC's Connect button would only try without a ticket,\n// and its control bar duplicates what the Orca tab does (fit, clipboard, keyboard release).\n// The pause card follows Orca's theme: Orca sets Electron's theme source from its own setting, so\n// prefers-color-scheme here is Orca's light or dark, and it follows a switch while paused. The\n// page cannot read Orca's tokens, so these mirror them (popover, border, focus ring).\nstyle.textContent = `\n#noVNC_connect_dlg, #noVNC_control_bar_anchor { display: none !important; }\n#orca_pause { --orca-scrim: rgb(10 10 10 / 0.88); --orca-card: #171717; --orca-text: #f0f0f0;\n --orca-border: rgb(255 255 255 / 0.1); --orca-control: rgb(255 255 255 / 0.25);\n --orca-control-hover: rgb(255 255 255 / 0.08); --orca-focus: color-mix(in oklab, #f0f0f0 65%, #0a0a0a);\n color-scheme: dark; position: fixed; inset: 0; display: none; align-items: center;\n justify-content: center; padding: 16px; background: var(--orca-scrim); z-index: 1000;\n font: 13px/1.5 system-ui, sans-serif; }\n@media (prefers-color-scheme: light) {\n #orca_pause { --orca-scrim: rgb(255 255 255 / 0.88); --orca-card: #fff; --orca-text: #0a0a0a;\n --orca-border: #e5e5e5; --orca-control: #a3a3a3; --orca-control-hover: #f5f5f5;\n --orca-focus: color-mix(in oklab, #0a0a0a 55%, #fff); color-scheme: light; }\n}\n#orca_pause.open { display: flex; }\n#orca_pause > div { max-width: 360px; padding: 16px; border: 1px solid var(--orca-border);\n border-radius: 8px; background: var(--orca-card); color: var(--orca-text); text-align: center;\n box-shadow: 0 8px 24px rgb(0 0 0 / 0.16); }\n#orca_pause p { margin: 0; }\n#orca_pause button { margin-top: 12px; padding: 4px 12px; border: 1px solid var(--orca-control);\n border-radius: 6px; background: transparent; color: var(--orca-text); font: inherit; cursor: pointer; }\n#orca_pause button:hover { background: var(--orca-control-hover); }\n#orca_pause button:focus-visible { outline: 2px solid var(--orca-focus); outline-offset: 2px; }\n@media (prefers-reduced-motion: no-preference) {\n #orca_pause.open > div { animation: orca-pause-in 120ms ease-out; }\n}\n@keyframes orca-pause-in { from { opacity: 0; transform: translateY(4px); } }\n`;\ndocument.head.appendChild(style);\n\nconst overlay = document.createElement('div');\noverlay.id = 'orca_pause';\noverlay.innerHTML = '

';\noverlay.querySelector('button').addEventListener('click', () => resume());\ndocument.addEventListener('DOMContentLoaded', () => document.body.appendChild(overlay));\n\nwindow.addEventListener('keydown', (event) => {\n if ((event.ctrlKey || event.metaKey) && !event.altKey && (event.key === 'c' || event.key === 'C' || event.key === 'Insert')) {\n lastCopyIntent = Date.now();\n }\n}, true);\nwindow.addEventListener('pointerdown', (event) => {\n pointerStart = { x: event.clientX, y: event.clientY };\n}, true);\n// A double- or triple-click selects a word or line (pointer events carry no click count).\nwindow.addEventListener('mousedown', (event) => {\n if (event.detail >= 2) {\n lastCopyIntent = Date.now();\n }\n}, true);\nwindow.addEventListener('pointerup', (event) => {\n if (pointerStart && Math.hypot(event.clientX - pointerStart.x, event.clientY - pointerStart.y) >= DRAG_PX) {\n lastCopyIntent = Date.now();\n }\n pointerStart = null;\n}, true);\n\nfunction requestTicket() {\n const answer = attemptConnected ? 'ticket' : 'retry';\n const waiters = ticketWaiters;\n ticketWaiters = [];\n waiters.forEach((resolve) => resolve(answer));\n}\n\nasync function whenStarted() {\n while (document.documentElement.classList.contains('noVNC_loading')) {\n await new Promise((resolve) => setTimeout(resolve, 25));\n }\n}\n\nfunction onConnect() {\n state = 'connected';\n attemptConnected = true;\n UI.hideStatus();\n setTimeout(() => {\n // Xvnc answers SetDesktopSize; anything that does not gets scaled into the tab instead.\n if (UI.rfb && state === 'connected' && !UI.rfb._supportsSetDesktopSize) {\n UI.rfb.scaleViewport = true;\n }\n }, RESIZE_FALLBACK_MS);\n}\n\nfunction onDisconnect() {\n if (state === 'paused') {\n return;\n }\n state = 'disconnected';\n // The ticket is spent: ask Orca for a new one (a dropped forward, a restart of the desktop).\n requestTicket();\n}\n\nfunction onClipboard(event) {\n const text = event.detail && event.detail.text;\n if (typeof text !== 'string' || text.length > MAX_CLIPBOARD_CHARS) {\n return;\n }\n if (Date.now() - lastCopyIntent > USER_COPY_WINDOW_MS || !document.hasFocus()) {\n return;\n }\n navigator.clipboard.writeText(text).catch(() => {});\n}\n\nasync function connect(ticket) {\n if (typeof ticket !== 'string' || !TICKET_RE.test(ticket)) {\n return 'invalid';\n }\n if (state === 'connecting' || state === 'connected' || state === 'paused') {\n return state;\n }\n await whenStarted();\n if (UI.rfb) {\n return 'connecting';\n }\n state = 'connecting';\n attemptConnected = false;\n // UI.connect reads the path setting synchronously and opens the WebSocket in RFB's constructor;\n // the in-memory setting is restored right after, so the ticket is never kept or shown.\n // Only ever this page's own origin: noVNC also reads host, port, encrypt, repeater and logging\n // from the URL, which must never send a ticketed session (and the user's keys) elsewhere.\n WebUtil.setSetting('host', '');\n WebUtil.setSetting('port', '');\n WebUtil.setSetting('encrypt', false);\n WebUtil.setSetting('repeaterID', '');\n WebUtil.setSetting('path', `${WS_PATH}?ticket=${ticket}`);\n try {\n UI.connect();\n } finally {\n WebUtil.setSetting('path', WS_PATH);\n }\n const rfb = UI.rfb;\n if (!rfb) {\n state = 'disconnected';\n requestTicket();\n return 'failed';\n }\n rfb.addEventListener('connect', onConnect);\n rfb.addEventListener('disconnect', onDisconnect);\n rfb.addEventListener('clipboard', onClipboard);\n return 'connecting';\n}\n\n/** Pastes this computer's clipboard: the sandbox's clipboard first, then the paste key itself. */\nfunction paste(text, chord) {\n const rfb = UI.rfb;\n if (!rfb || state !== 'connected' || typeof text !== 'string' || text.length > MAX_CLIPBOARD_CHARS) {\n return false;\n }\n rfb.clipboardPasteFrom(text);\n if (chord && chord.kind === 'mac') {\n // Cmd+V: Linux apps do not paste on Super+V, so release Super and send Shift+Insert.\n rfb.sendKey(XK.Super_L, 'MetaLeft', false);\n rfb.sendKey(XK.Super_R, 'MetaRight', false);\n rfb.sendKey(XK.Shift_L, 'ShiftLeft', true);\n rfb.sendKey(XK.Insert, 'Insert');\n rfb.sendKey(XK.Shift_L, 'ShiftLeft', false);\n } else if (chord && chord.kind === 'replay') {\n // Ctrl+V, Ctrl+Shift+V, Shift+Insert: the held modifiers already reached the sandbox.\n const insert = chord.key === 'Insert';\n rfb.sendKey(insert ? XK.Insert : chord.key === 'V' ? XK.V : XK.v, insert ? 'Insert' : 'KeyV');\n }\n return true;\n}\n\nfunction pause(message, label, tone) {\n state = 'paused';\n if (UI.rfb) {\n UI.rfb.disconnect();\n }\n UI.hideStatus();\n overlay.querySelector('p').textContent = String(message || '');\n overlay.querySelector('button').textContent = String(label || 'Reconnect');\n // Asleep and starting are states, not errors: announce them politely.\n overlay.firstElementChild.setAttribute('role', tone === 'neutral' ? 'status' : 'alert');\n overlay.classList.add('open');\n overlay.querySelector('button').focus();\n return true;\n}\n\nfunction resume() {\n if (state !== 'paused') {\n return false;\n }\n overlay.classList.remove('open');\n state = 'disconnected';\n attemptConnected = true; // a person asked: start the retry budget over\n requestTicket();\n return true;\n}\n\nObject.defineProperty(window, 'orcaDesktop', {\n value: Object.freeze({\n version: 1,\n state: () => state,\n /** Resolves when the page needs a ticket: now if it is not connected, else after a drop. */\n nextTicketRequest: () => new Promise((resolve) => {\n ticketWaiters.push(resolve);\n if (state === 'idle' || state === 'disconnected') {\n requestTicket();\n }\n }),\n connect,\n paste,\n pause,\n resume\n })\n});\n","orca-sandbox-grant":"#!/usr/bin/env bash\n# Mints a fresh, single-device orcad pairing offer for one org member's device and seals it to that\n# device's X25519 key, so the control plane relays only ciphertext (the VM owner's E2EE model holds:\n# every member device gets its own revocable orcad credential, nobody else can read it).\n# Env from the control plane: ORCA_GRANT_ID, ORCA_GRANT_RECIPIENT_KEY (base64 raw X25519 public\n# key), ORCA_GRANT_KIND (desktop|mobile), ORCA_PUBLIC_WSS. Prints one JSON line:\n# {\"deviceId\":\"…\",\"sealed\":{\"v\":1,\"ephemeralPublicKeyB64\":\"…\",\"nonceB64\":\"…\",\"ciphertextB64\":\"…\"}}\n# Sealing: ECDH(ephemeral, recipient) -> HKDF-SHA256(salt = eph||recipient, info\n# \"orca-cloud-grant-v1\") -> AES-256-GCM, AAD \"orca-cloud-grant-v1:\".\nset -euo pipefail\numask 077\nORCA_HOME=/opt/orca\nSTATE=\"$HOME/.orca-sandbox\"\nDATA=\"$HOME/.orcad-data\"\nmkdir -p \"$STATE\"\nexec 9>\"$STATE/grant.lock\"\n# One mint at a time: --rotate retires unredeemed offers, so two members never share a credential.\nflock -w 30 9\n\ncase \"${ORCA_GRANT_ID:-}\" in '' | *[!A-Za-z0-9_-]*) echo 'bad grant id' >&2; exit 2 ;; esac\ncase \"${ORCA_GRANT_KIND:-}\" in desktop) scope=() ;; mobile) scope=(--mobile) ;; *) echo 'bad kind' >&2; exit 2 ;; esac\ncase \"${ORCA_GRANT_RECIPIENT_KEY:-}\" in '' | *[!A-Za-z0-9+/=]*) echo 'bad key' >&2; exit 2 ;; esac\ncase \"${ORCA_PUBLIC_WSS:-}\" in wss://*) ;; *) echo 'bad endpoint' >&2; exit 2 ;; esac\n\nnode=\"$(find \"$ORCA_HOME/runtime/runtimes\" -type f -name node | head -n 1)\"\ncli=\"$ORCA_HOME/runtime/orcad/out/cli/index.js\"\n# The workspace's project must exist on this orcad before a phone opens it: phones may not add\n# projects themselves (mobile RPC scope), and a phone may be the first client this VM ever sees.\nproject=/vercel/sandbox/project\nif [ -d \"$project\" ]; then\n kind=folder\n [ -d \"$project/.git\" ] && kind=git\n ORCA_USER_DATA_PATH=\"$DATA\" timeout 20 \"$node\" \"$cli\" repo add --path \"$project\" --kind \"$kind\" --json \\\n >/dev/null 2>&1 || true\nfi\noffer=\"$(ORCA_USER_DATA_PATH=\"$DATA\" timeout 30 \"$node\" \"$cli\" pair --json --rotate \"${scope[@]}\" \\\n --address \"$ORCA_PUBLIC_WSS\" 2>/dev/null)\" || { echo 'pair failed' >&2; exit 1; }\n# The offer goes to the sealer on stdin (never argv or disk); only the sealed form is printed.\nprintf '%s' \"$offer\" | ORCA_GRANT_ID=\"$ORCA_GRANT_ID\" ORCA_GRANT_RECIPIENT_KEY=\"$ORCA_GRANT_RECIPIENT_KEY\" \\\n \"$node\" -e '\nconst crypto = require(\"node:crypto\")\nlet input = \"\"\nprocess.stdin.on(\"data\", (c) => (input += c)).on(\"end\", () => {\n const res = JSON.parse(input).result\n if (!res || res.available !== true || !res.pairingUrl || !res.deviceId) {\n console.error(\"offer unavailable\")\n process.exit(1)\n }\n const recipient = Buffer.from(process.env.ORCA_GRANT_RECIPIENT_KEY, \"base64\")\n if (recipient.length !== 32) { console.error(\"bad key length\"); process.exit(2) }\n const recipientKey = crypto.createPublicKey({ key: { kty: \"OKP\", crv: \"X25519\", x: recipient.toString(\"base64url\") }, format: \"jwk\" })\n const eph = crypto.generateKeyPairSync(\"x25519\")\n const ephRaw = Buffer.from(eph.publicKey.export({ format: \"jwk\" }).x, \"base64url\")\n const shared = crypto.diffieHellman({ privateKey: eph.privateKey, publicKey: recipientKey })\n const key = Buffer.from(crypto.hkdfSync(\"sha256\", shared, Buffer.concat([ephRaw, recipient]), \"orca-cloud-grant-v1\", 32))\n const nonce = crypto.randomBytes(12)\n const cipher = crypto.createCipheriv(\"aes-256-gcm\", key, nonce)\n cipher.setAAD(Buffer.from(\"orca-cloud-grant-v1:\" + process.env.ORCA_GRANT_ID))\n const body = Buffer.from(JSON.stringify({ pairingUrl: res.pairingUrl, deviceId: res.deviceId, scope: res.scope }))\n const ct = Buffer.concat([cipher.update(body), cipher.final(), cipher.getAuthTag()])\n process.stdout.write(JSON.stringify({ deviceId: res.deviceId, sealed: { v: 1, ephemeralPublicKeyB64: ephRaw.toString(\"base64\"), nonceB64: nonce.toString(\"base64\"), ciphertextB64: ct.toString(\"base64\") } }) + \"\\n\")\n})'\n","orca-sandbox-revoke":"#!/usr/bin/env bash\n# Revokes member devices from orcad's device registry. orcad adopts on-disk removals at every auth\n# (an admin revoke, device-registry-store.ts), so this works whether or not orcad is running; the\n# control plane also runs it at boot, before orcad starts, for revokes queued while suspended.\n# Env: ORCA_REVOKE_DEVICE_IDS (comma list of orcad device ids). Prints {\"revoked\":,\"live\":}.\nset -euo pipefail\numask 077\nSTATE=\"$HOME/.orca-sandbox\"\nREGISTRY=\"$HOME/.orcad-data/orca-devices.json\"\nmkdir -p \"$STATE\"\nexec 9>\"$STATE/grant.lock\"\nflock -w 30 9\n\nids=\"${ORCA_REVOKE_DEVICE_IDS:-}\"\ncase \"$ids\" in '' | *[!A-Za-z0-9,_-]*) echo 'bad device ids' >&2; exit 2 ;; esac\n# Live orcad first: `orca pair --revoke` also closes the device's open sockets now. Older orcad\n# builds lack it; the on-disk removal below still blocks their next sign-in.\nORCA_HOME=/opt/orca\nnode=\"$(find \"$ORCA_HOME/runtime/runtimes\" -type f -name node 2>/dev/null | head -n 1)\"\ncli=\"$ORCA_HOME/runtime/orcad/out/cli/index.js\"\nlive=0\nif [ -n \"$node\" ] && [ -f \"$cli\" ] && [ -s \"$HOME/.orcad-data/orca-runtime.json\" ]; then\n for id in ${ids//,/ }; do\n if ORCA_USER_DATA_PATH=\"$HOME/.orcad-data\" timeout 15 \"$node\" \"$cli\" pair --revoke \"$id\" --json 2>/dev/null \\\n | jq -e '.ok == true and .result.revoked == true' >/dev/null 2>&1; then\n live=$((live + 1))\n fi\n done\nfi\nif [ ! -s \"$REGISTRY\" ]; then\n echo \"{\\\"revoked\\\":$live,\\\"live\\\":$live}\"\n exit 0\nfi\nids_json=\"$(jq -cn --arg ids \"$ids\" '$ids | split(\",\") | map(select(length > 0))')\"\nbefore=\"$(jq 'length' \"$REGISTRY\")\"\ntmp=\"$(mktemp \"$REGISTRY.revoke.XXXXXX\")\"\n# Removes the rows and any phones delegated through them (parentDeviceId), like orcad's own revoke.\njq --argjson ids \"$ids_json\" \\\n '[.[] | select((.deviceId as $d | $ids | index($d)) == null and ((.parentDeviceId // \"\") as $p | $ids | index($p)) == null)]' \\\n \"$REGISTRY\" >\"$tmp\"\nchmod 0600 \"$tmp\"\nsync \"$tmp\" 2>/dev/null || true\nmv -f \"$tmp\" \"$REGISTRY\"\nafter=\"$(jq 'length' \"$REGISTRY\")\"\necho \"{\\\"revoked\\\":$((live + before - after)),\\\"live\\\":$live}\"\n","orca-sandbox-members":"#!/usr/bin/env bash\n# Runs as root (control plane, sudo). Installs who-may-push-as-whom for `orca-git-as`:\n# /etc/orca/members/.gitconfig egress placeholder header + GitHub author identity\n# /etc/orca/members/devices.json {\"\": \"\"} (each member's paired devices)\n# Both root-only: agents never read another member's placeholder. `orca-git-identity` (root, via a\n# sudoers rule) hands an agent only the identity of the member whose device drove its turn, as orcad\n# attests it. No token lives here: the placeholder is swapped at egress, for this repository only.\n# Env: ORCA_MEMBERS_B64 = base64 JSON [{userId, name, email, authorization, deviceIds:[...]}]\n# The VM user agents run as is orcad's own user (detected). Prints {\"members\":,\"devices\":}.\nset -euo pipefail\numask 077\nDIR=/etc/orca/members\norcad_pid=\"$(pgrep -f orcad-server.js | head -n 1 || true)\"\nUSER_NAME=\"$( [ -n \"$orcad_pid\" ] && ps -o user= -p \"$orcad_pid\" | tr -d ' ' || true)\"\nUSER_NAME=\"${USER_NAME:-${ORCA_SANDBOX_USER:-${SUDO_USER:-}}}\"\ncase \"$USER_NAME\" in '' | *[!a-z0-9_-]*) echo 'bad user' >&2; exit 2 ;; esac\nmkdir -p /etc/orca\njson=\"$(printf '%s' \"${ORCA_MEMBERS_B64:-W10=}\" | base64 -d)\"\ntmp=\"$(mktemp -d /etc/orca/members.XXXXXX)\"\ncount=0\nwhile IFS= read -r row; do\n user=\"$(jq -r '.userId' <<<\"$row\")\"\n case \"$user\" in '' | *[!A-Za-z0-9_.:-]*) continue ;; esac\n file=\"$tmp/$(printf '%s' \"$user\" | tr ':' '_').gitconfig\"\n # An empty extraheader first resets the image-wide (app identity) header for this member's git.\n git config -f \"$file\" --add http.https://github.com/.extraheader ''\n git config -f \"$file\" --add http.https://github.com/.extraheader \"Authorization: $(jq -r '.authorization' <<<\"$row\")\"\n git config -f \"$file\" user.name \"$(jq -r '.name' <<<\"$row\")\"\n git config -f \"$file\" user.email \"$(jq -r '.email' <<<\"$row\")\"\n count=$((count + 1))\ndone < <(jq -c '.[]' <<<\"$json\")\njq -c '[.[] | select(.userId | test(\"^[A-Za-z0-9_.:-]+$\")) | .userId as $u | (.deviceIds // [])[] | select(test(\"^[A-Za-z0-9_-]{1,128}$\")) | {key: ., value: $u}] | from_entries' <<<\"$json\" >\"$tmp/devices.json\"\ndevices=\"$(jq 'length' \"$tmp/devices.json\")\"\nchmod 0700 \"$tmp\" && chmod 0600 \"$tmp\"/*\nrm -rf \"$DIR.old\"\n[ -d \"$DIR\" ] && mv \"$DIR\" \"$DIR.old\"\nmv \"$tmp\" \"$DIR\"\nrm -rf \"$DIR.old\"\n# Agents may ask for their own sender's identity, and only that (the helper checks with orcad).\nrule=\"$USER_NAME ALL=(root) NOPASSWD:SETENV: /opt/orca/bin/orca-git-identity\"\nprintf '%s\\n' \"$rule\" >/etc/sudoers.d/orca-git-identity.new\nchmod 0440 /etc/sudoers.d/orca-git-identity.new\nif visudo -cf /etc/sudoers.d/orca-git-identity.new >/dev/null; then\n mv -f /etc/sudoers.d/orca-git-identity.new /etc/sudoers.d/orca-git-identity\nelse\n rm -f /etc/sudoers.d/orca-git-identity.new\n echo 'sudoers rule rejected' >&2\n exit 1\nfi\n# Pre-attestation layout (agent-readable member files) must not linger.\nuser_home=\"$(getent passwd \"$USER_NAME\" | cut -d: -f6)\"\n[ -n \"$orcad_pid\" ] && user_home=\"$(tr '\\0' '\\n' <\"/proc/$orcad_pid/environ\" | sed -n 's/^HOME=//p' | head -n 1)\"\n[ -n \"$user_home\" ] && rm -rf \"$user_home/.orca-sandbox/members\"\n# Commits outside a teammate's turn still need an author (images older than orca-sandbox-start's default).\nif [ -n \"$user_home\" ]; then\n sudo -u \"$USER_NAME\" env HOME=\"$user_home\" git config --global user.email >/dev/null 2>&1 \\\n || sudo -u \"$USER_NAME\" env HOME=\"$user_home\" git config --global user.email 'cloud@users.noreply.onorca.dev'\n sudo -u \"$USER_NAME\" env HOME=\"$user_home\" git config --global user.name >/dev/null 2>&1 \\\n || sudo -u \"$USER_NAME\" env HOME=\"$user_home\" git config --global user.name 'Orca Cloud'\nfi\necho \"{\\\"members\\\":$count,\\\"devices\\\":$devices}\"\n","orca-sandbox-read-snapshot":"#!/usr/bin/env bash\n# Seals a read-only snapshot of this workspace (chats, agent status, git, PR) to the reader keys the\n# control plane passes, right before the drain. Only ciphertext is printed (one JSON line); see\n# orca-read-snapshot.cjs. Exit 3: orcad isn't running (nothing to read).\nset -euo pipefail\numask 077\nORCA_HOME=/opt/orca\nexport ORCA_USER_DATA_PATH=\"${ORCA_USER_DATA_PATH:-$HOME/.orcad-data}\"\nnode=\"$(find \"$ORCA_HOME/runtime/runtimes\" -type f -name node | head -n 1)\"\n[ -n \"$node\" ] || { echo 'node not found' >&2; exit 1; }\nexec timeout 35 \"$node\" \"$ORCA_HOME/bin/orca-read-snapshot.cjs\"\n","orca-read-snapshot.cjs":"#!/usr/bin/env node\n// Gathers what a sleeping workspace should still show (recent chats per agent session, agent\n// status, git status/diff summary, PR link) from the running orcad over its local socket, then seals\n// it to the reader keys the control plane passed, so only ciphertext leaves the VM.\n// Run by orca-sandbox-read-snapshot right before the drain. Env:\n// ORCA_READ_SNAPSHOT_ID rsn_<24 hex> ORCA_READ_WORKSPACE_ID sbx_<24 hex>\n// ORCA_READ_RECIPIENTS JSON [{keyId, publicKeyB64}] ORCA_READ_REASON sleep|rollover\n// ORCA_USER_DATA_PATH orcad's data dir (orca-runtime.json lives there)\n// Prints one JSON line: {v:1, snapshotId, workspaceId, nonceB64, ciphertextB64, recipients[], stats}.\n// Construction (keep in sync with src/shared/cloud-workspaces/read-snapshot.ts in the app):\n// body = AES-256-GCM(dek, nonce, JSON, AAD \"orca-cloud-read-v1::\")\n// wrapped = AES-256-GCM(HKDF-SHA256(X25519(eph, reader), eph||reader, \"orca-cloud-read-wrap-v1\"),\n// nonce_i, dek, AAD \"orca-cloud-read-wrap-v1:::\")\n'use strict'\nconst crypto = require('node:crypto')\nconst fs = require('node:fs')\nconst net = require('node:net')\nconst path = require('node:path')\n\nconst INFO = 'orca-cloud-read-v1'\nconst WRAP_INFO = 'orca-cloud-read-wrap-v1'\nconst PROJECT = '/vercel/sandbox/project'\nconst LIMITS = { sessions: 12, messagesPerSession: 60, messageChars: 4000, changes: 200, commits: 10 }\n/** Plaintext budget: sealed + base64 it stays under the control plane's 220 kB and the 256 kB stdout cap. */\nconst MAX_PLAIN_BYTES = 150_000\nconst CALL_TIMEOUT_MS = 5_000\nconst TOTAL_BUDGET_MS = 20_000\n\nfunction b64(bytes) {\n return Buffer.from(bytes).toString('base64')\n}\n\nfunction x25519PublicKey(raw) {\n return crypto.createPublicKey({ key: { kty: 'OKP', crv: 'X25519', x: Buffer.from(raw).toString('base64url') }, format: 'jwk' })\n}\n\nfunction gcmSeal(key, nonce, plain, aad) {\n const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce)\n cipher.setAAD(Buffer.from(aad))\n return Buffer.concat([cipher.update(plain), cipher.final(), cipher.getAuthTag()])\n}\n\n/** Seals `payload` (an object) to every recipient; a malformed key is skipped, not fatal. */\nfunction seal(payload, recipients, workspaceId, snapshotId) {\n const scope = `${workspaceId}:${snapshotId}`\n const dek = crypto.randomBytes(32)\n const nonce = crypto.randomBytes(12)\n const ciphertext = gcmSeal(dek, nonce, Buffer.from(JSON.stringify(payload)), `${INFO}:${scope}`)\n const sealedTo = []\n for (const recipient of recipients) {\n const reader = Buffer.from(String(recipient.publicKeyB64 || ''), 'base64')\n if (reader.length !== 32 || !/^rk_[0-9a-f]{24}$/.test(String(recipient.keyId || ''))) {\n continue\n }\n let shared\n const eph = crypto.generateKeyPairSync('x25519')\n try {\n shared = crypto.diffieHellman({ privateKey: eph.privateKey, publicKey: x25519PublicKey(reader) })\n } catch {\n continue\n }\n if (shared.every((byte) => byte === 0)) {\n continue\n }\n const ephRaw = Buffer.from(eph.publicKey.export({ format: 'jwk' }).x, 'base64url')\n const kek = Buffer.from(crypto.hkdfSync('sha256', shared, Buffer.concat([ephRaw, reader]), WRAP_INFO, 32))\n const wrapNonce = crypto.randomBytes(12)\n const wrapped = gcmSeal(kek, wrapNonce, dek, `${WRAP_INFO}:${scope}:${recipient.keyId}`)\n sealedTo.push({ keyId: recipient.keyId, ephemeralPublicKeyB64: b64(ephRaw), nonceB64: b64(wrapNonce), wrappedKeyB64: b64(wrapped) })\n }\n dek.fill(0)\n return { v: 1, snapshotId, workspaceId, nonceB64: b64(nonce), ciphertextB64: b64(ciphertext), recipients: sealedTo }\n}\n\n// --- gathering -------------------------------------------------------------------------------\n\n/** One request per connection, like the CLI. A streaming method resolves on its first frame. */\nfunction rpc(metadata, method, params, timeoutMs = CALL_TIMEOUT_MS) {\n return new Promise((resolve) => {\n const transport = (metadata.transports || [metadata.transport]).find((t) => t && (t.kind === 'unix' || t.kind === 'named-pipe'))\n if (!transport) {\n resolve(null)\n return\n }\n const socket = net.createConnection(transport.endpoint)\n const id = crypto.randomUUID()\n let buffer = ''\n let done = false\n const finish = (value) => {\n if (!done) {\n done = true\n clearTimeout(timer)\n socket.destroy()\n resolve(value)\n }\n }\n const timer = setTimeout(() => finish(null), timeoutMs)\n socket.setEncoding('utf8')\n socket.on('error', () => finish(null))\n socket.on('close', () => finish(null))\n socket.on('connect', () => socket.write(`${JSON.stringify({ id, authToken: metadata.authToken, method, params })}\\n`))\n socket.on('data', (chunk) => {\n buffer += chunk\n let newline\n while ((newline = buffer.indexOf('\\n')) !== -1) {\n const line = buffer.slice(0, newline)\n buffer = buffer.slice(newline + 1)\n let frame\n try {\n frame = JSON.parse(line)\n } catch {\n continue\n }\n if (!frame || frame.id !== id) {\n continue\n }\n finish(frame.ok === true ? frame.result : null)\n return\n }\n })\n })\n}\n\nconst isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v)\nconst str = (v, max) => (typeof v === 'string' ? v.slice(0, max) : null)\nconst num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null)\n\nfunction messagesOf(history) {\n const items = isObj(history) && isObj(history.page) && Array.isArray(history.page.items) ? history.page.items : []\n const out = []\n for (const item of items) {\n const body = isObj(item) && isObj(item.body) ? item.body : null\n if (!body || body.kind !== 'message' || !Array.isArray(body.blocks)) {\n continue\n }\n const role = body.role\n if (role !== 'user' && role !== 'assistant' && role !== 'system') {\n continue\n }\n const text = body.blocks\n .filter((b) => isObj(b) && b.type === 'text' && typeof b.text === 'string')\n .map((b) => b.text)\n .join('\\n')\n .trim()\n if (text) {\n out.push({ itemId: String(item.itemId).slice(0, 200), role, text: text.slice(0, LIMITS.messageChars), at: num(item.observedAt) ?? 0 })\n }\n }\n return { messages: out, hasOlder: isObj(history) && isObj(history.page) && history.page.hasOlder === true }\n}\n\nfunction gitOf(status, log) {\n if (!isObj(status) && !isObj(log)) {\n return null\n }\n const entries = isObj(status) && Array.isArray(status.entries) ? status.entries.filter(isObj) : []\n let added = 0\n let removed = 0\n let counted = false\n const changes = entries.slice(0, LIMITS.changes).map((e) => {\n const a = num(e.added)\n const r = num(e.removed)\n if (a !== null || r !== null) {\n counted = true\n }\n return { path: String(e.path).slice(0, 1024), status: str(e.status, 20) || 'modified', area: str(e.area, 20) || 'unstaged', added: a, removed: r }\n })\n for (const e of entries) {\n added += num(e.added) || 0\n removed += num(e.removed) || 0\n }\n const items = isObj(log) && Array.isArray(log.items) ? log.items.filter(isObj) : []\n return {\n branch: isObj(status) && typeof status.branch === 'string' ? status.branch.replace(/^refs\\/heads\\//, '') : null,\n head: isObj(status) ? str(status.head, 64) : null,\n changes,\n changeCount: entries.length,\n added: counted ? added : null,\n removed: counted ? removed : null,\n commits: items.slice(0, LIMITS.commits).map((c) => ({\n id: String(c.id).slice(0, 64),\n subject: String(c.subject ?? '').slice(0, 300),\n author: str(c.author, 120),\n at: num(c.timestamp)\n }))\n }\n}\n\nfunction prOf(linked) {\n if (!isObj(linked) || num(linked.number) === null || typeof linked.url !== 'string' || !linked.url.startsWith('https://')) {\n return null\n }\n return {\n number: linked.number,\n title: String(linked.title ?? '').slice(0, 300),\n state: str(linked.state, 20) || 'open',\n url: linked.url.slice(0, 500),\n checksStatus: str(linked.checksStatus, 20),\n checksSummary: str(linked.checksSummary, 200)\n }\n}\n\nconst STATUSES = new Set(['working', 'attention', 'idle'])\nconst PANE_PREFIX = 'structured-agent-session-'\n\n/**\n * Chats as orcad stores them (agent-session-journal.db, read-only): every session's provider, name\n * and last turn, open tabs first. The local socket can't stream agentSession.subscribeStatus, and\n * worktree.ps lists only agents that are live right now, so this is the complete list.\n */\nfunction storedSessions(dataDir) {\n let db\n try {\n const { DatabaseSync } = require('node:sqlite')\n db = new DatabaseSync(path.join(dataDir, 'agent-session-journal.db'), { readOnly: true })\n const open = new Set(db.prepare('SELECT session_id FROM agent_session_tabs').all().map((r) => r.session_id))\n const out = []\n for (const row of db.prepare('SELECT session_id, record_json FROM agent_session_records').all()) {\n let record\n try {\n record = JSON.parse(row.record_json)\n } catch {\n continue\n }\n const last = isObj(record.lastTurn) ? record.lastTurn : {}\n out.push({\n sessionId: row.session_id,\n agent: str(record.provider, 40),\n title: str(record.conversationName, 200) || str(last.prompt, 200),\n status: last.state === 'running' || last.state === 'submitted' ? 'working' : last.state === 'settled' ? 'idle' : 'unknown',\n turnOutcome: str(last.outcome, 40),\n updatedAt: num(record.updatedAt),\n open: open.has(row.session_id),\n lastPrompt: str(last.prompt, LIMITS.messageChars),\n lastReply: str(last.reply, LIMITS.messageChars),\n lastAt: num(last.at)\n })\n }\n return out\n } catch {\n return []\n } finally {\n try {\n db && db.close()\n } catch {}\n }\n}\n\n/** Live agent rows from worktree.ps, keyed by session id (their status wins over the stored one). */\nfunction liveAgents(worktrees) {\n const out = new Map()\n for (const w of worktrees) {\n for (const a of Array.isArray(w.agents) ? w.agents.filter(isObj) : []) {\n const tab = typeof a.paneKey === 'string' ? a.paneKey.split(':')[0] : ''\n if (!tab.startsWith(PANE_PREFIX)) {\n continue\n }\n const state = a.mainAgent && typeof a.mainAgent.state === 'string' ? a.mainAgent.state : a.state\n out.set(tab.slice(PANE_PREFIX.length), {\n agent: str(a.agentType, 40),\n title: str(a.conversationName, 200) || str(a.taskTitle, 200) || str(a.displayName, 200),\n status: state === 'working' ? 'working' : state === 'blocked' || state === 'waiting' || state === 'attention' ? 'attention' : 'idle',\n updatedAt: num(a.updatedAt)\n })\n }\n }\n return out\n}\n\n/** `call(method, params)` -> result | null. Never throws: a missing piece is left out. */\nasync function gather(call, { workspaceId, snapshotId, reason, now, deadline, listSessions = () => [] }) {\n const timeLeft = () => deadline - Date.now()\n const ps = await call('worktree.ps', { limit: 20 })\n const worktrees = isObj(ps) && Array.isArray(ps.worktrees) ? ps.worktrees.filter(isObj) : []\n const project = worktrees.find((w) => w.path === PROJECT) || worktrees[0] || null\n const selector = project && typeof project.path === 'string' ? `path:${project.path}` : `path:${PROJECT}`\n const [status, log] = await Promise.all([\n call('git.status', { worktree: selector, includeLineStats: true }),\n call('git.history', { worktree: selector, limit: LIMITS.commits })\n ])\n const live = liveAgents(worktrees)\n const byId = new Map()\n for (const s of listSessions()) {\n byId.set(s.sessionId, s)\n }\n for (const [sessionId, a] of live) {\n byId.set(sessionId, { ...(byId.get(sessionId) || { sessionId, open: true }), ...Object.fromEntries(Object.entries(a).filter(([, v]) => v !== null)) })\n }\n // Open chats first, then newest activity.\n const picked = [...byId.values()]\n .filter((s) => typeof s.sessionId === 'string')\n .sort((a, b) => Number(Boolean(b.open)) - Number(Boolean(a.open)) || (num(b.updatedAt) || 0) - (num(a.updatedAt) || 0))\n .slice(0, LIMITS.sessions)\n const sessions = []\n for (const s of picked) {\n const history = timeLeft() > 1_000 ? await call('agentSession.history', { sessionId: s.sessionId, direction: 'tail', limit: LIMITS.messagesPerSession }) : null\n let { messages, hasOlder } = messagesOf(history)\n if (messages.length === 0) {\n // No readable history (or out of time): the stored last turn still says what happened.\n const at = s.lastAt || s.updatedAt || 0\n messages = [\n ...(s.lastPrompt ? [{ itemId: `${s.sessionId}:last-prompt`, role: 'user', text: s.lastPrompt, at }] : []),\n ...(s.lastReply ? [{ itemId: `${s.sessionId}:last-reply`, role: 'assistant', text: s.lastReply, at }] : [])\n ]\n hasOlder = hasOlder || messages.length > 0\n }\n sessions.push({\n sessionId: s.sessionId.slice(0, 200),\n agent: s.agent || null,\n title: s.title || null,\n status: STATUSES.has(s.status) ? s.status : 'unknown',\n turnOutcome: s.turnOutcome || null,\n updatedAt: num(s.updatedAt),\n messages: messages.slice(-LIMITS.messagesPerSession),\n truncated: hasOlder || messages.length > LIMITS.messagesPerSession\n })\n }\n return {\n v: 1,\n workspaceId,\n snapshotId,\n capturedAt: now,\n reason,\n git: gitOf(status, log),\n pr: prOf(project && project.linkedPR),\n sessions\n }\n}\n\n/** Cuts the oldest messages (then long texts, then sessions) until the JSON fits the budget. */\nfunction fitToBudget(payload, maxBytes = MAX_PLAIN_BYTES) {\n const size = () => Buffer.byteLength(JSON.stringify(payload))\n let guard = 0\n while (size() > maxBytes && guard++ < 10_000) {\n const longest = payload.sessions.reduce((best, s) => (!best || s.messages.length > best.messages.length ? s : best), null)\n if (longest && longest.messages.length > 4) {\n longest.messages.shift()\n longest.truncated = true\n continue\n }\n const longText = payload.sessions.flatMap((s) => s.messages).find((m) => m.text.length > 500)\n if (longText) {\n longText.text = `${longText.text.slice(0, 500)}…`\n continue\n }\n if (payload.git && payload.git.changes.length > 20) {\n payload.git.changes = payload.git.changes.slice(0, 20)\n continue\n }\n if (payload.sessions.length > 1) {\n payload.sessions.pop()\n continue\n }\n payload.sessions = []\n break\n }\n return payload\n}\n\nasync function main() {\n const started = Date.now()\n const env = process.env\n const snapshotId = env.ORCA_READ_SNAPSHOT_ID || ''\n const workspaceId = env.ORCA_READ_WORKSPACE_ID || ''\n if (!/^rsn_[0-9a-f]{24}$/.test(snapshotId) || !/^sbx_[0-9a-f]{24}$/.test(workspaceId)) {\n process.stderr.write('bad ids\\n')\n process.exit(2)\n }\n let recipients\n try {\n recipients = JSON.parse(env.ORCA_READ_RECIPIENTS || '[]')\n } catch {\n recipients = null\n }\n if (!Array.isArray(recipients) || recipients.length === 0) {\n process.stderr.write('no recipients\\n')\n process.exit(2)\n }\n const dataDir = env.ORCA_USER_DATA_PATH || path.join(env.HOME || '', '.orcad-data')\n let metadata\n try {\n metadata = JSON.parse(fs.readFileSync(path.join(dataDir, 'orca-runtime.json'), 'utf8'))\n } catch {\n metadata = null\n }\n if (!metadata || !metadata.authToken) {\n process.stderr.write('orcad not running\\n')\n process.exit(3)\n }\n const deadline = started + TOTAL_BUDGET_MS\n const call = (method, params) => rpc(metadata, method, params, Math.max(250, Math.min(CALL_TIMEOUT_MS, deadline - Date.now())))\n const payload = fitToBudget(\n await gather(call, { workspaceId, snapshotId, reason: (env.ORCA_READ_REASON || 'sleep').slice(0, 20), now: Date.now(), deadline, listSessions: () => storedSessions(dataDir) })\n )\n const out = seal(payload, recipients, workspaceId, snapshotId)\n // Timing only: counts and sizes would describe the plaintext to the control plane's logs.\n out.stats = { collectMs: Date.now() - started }\n process.stdout.write(`${JSON.stringify(out)}\\n`)\n}\n\nmodule.exports = { seal, gather, fitToBudget, messagesOf, gitOf, prOf, rpc, storedSessions, liveAgents }\n\nif (require.main === module) {\n // A fixed message: an error text could carry workspace content into the control plane's logs.\n main().catch(() => {\n process.stderr.write('read snapshot failed\\n')\n process.exit(1)\n })\n}\n","orca-git-as":"#!/usr/bin/env bash\n# Runs git as the teammate whose message started this agent's turn: their GitHub identity for\n# pushes/PRs (this repository only) and their commit author.\n# orca-git-as e.g. orca-git-as push origin HEAD\n# orca-git-as --as refuses unless that member really sent the message\n# Orca attests the sender from the paired device that sent the message, never from arguments or\n# message text. Without an attested sender (not run from an agent, or the owner's local session) it\n# runs plain git with the workspace identity.\nset -euo pipefail\nexpect=''\nif [ \"${1:-}\" = '--as' ]; then\n expect=\"${2:-}\"\n shift 2 || { echo 'usage: orca-git-as [--as ] ' >&2; exit 2; }\n case \"$expect\" in '' | *[!A-Za-z0-9_.:-]*) echo 'orca-git-as: bad member id' >&2; exit 2 ;; esac\nfi\nset +e\nfile=\"$(ORCA_GIT_AS=\"$expect\" sudo -n --preserve-env=ORCA_GIT_AS,ORCA_TERMINAL_HANDLE,ORCA_PANE_KEY,ORCA_AGENT_LAUNCH_TOKEN,ORCA_AGENT_SESSION_ID \\\n /opt/orca/bin/orca-git-identity)\"\nstatus=$?\nset -e\ncase \"$status\" in\n 0)\n trap 'rm -f \"$file\"' EXIT\n git -c \"include.path=$file\" \"$@\"\n ;;\n 3)\n echo 'orca-git-as: no teammate identity for this turn; using the workspace identity' >&2\n exec git \"$@\"\n ;;\n *) exit 4 ;;\nesac\n","orca-git-identity":"#!/usr/bin/env bash\n# Root helper behind `orca-git-as` (sudoers: the VM user may run only this). Asks orcad, as the\n# calling agent, which paired device sent the message that started the agent's latest turn\n# (`orca sender`: orcad identifies the agent from its launch evidence, never from arguments), maps\n# that device to a workspace member, and prints that member's git config file for the caller to\n# include. Optional ORCA_GIT_AS: the member the agent expects; any other answer is refused.\n# Exit codes: 0 printed a config path; 3 no member identity (use the workspace identity); 4 refused.\nset -euo pipefail\nDIR=/etc/orca/members\ncaller=\"${SUDO_USER:-}\"\ncase \"$caller\" in '' | root | *[!a-z0-9_-]*) echo 'orca-git-identity: run through orca-git-as' >&2; exit 4 ;; esac\n# orcad's own data dir and HOME (the agent's user may not use its passwd home, e.g. HOME=/vercel).\norcad_pid=\"$(pgrep -u \"$caller\" -f orcad-server.js | head -n 1 || true)\"\n[ -n \"$orcad_pid\" ] || exit 3\norcad_env() { tr '\\0' '\\n' <\"/proc/$orcad_pid/environ\" | sed -n \"s/^$1=//p\" | head -n 1; }\nhome=\"$(orcad_env HOME)\"\ndata=\"$(orcad_env ORCA_USER_DATA)\"\ndata=\"${data:-$home/.orcad-data}\"\nnode=\"$(find /opt/orca/runtime/runtimes -type f -name node | head -n 1)\"\ncli=/opt/orca/runtime/orcad/out/cli/index.js\n# Only the evidence variables orcad needs reach the query, which runs as the caller, not root.\nanswer=\"$(sudo -u \"$caller\" env -i HOME=\"$home\" PATH=/usr/bin:/bin ORCA_USER_DATA_PATH=\"$data\" \\\n ${ORCA_TERMINAL_HANDLE:+ORCA_TERMINAL_HANDLE=\"$ORCA_TERMINAL_HANDLE\"} \\\n ${ORCA_PANE_KEY:+ORCA_PANE_KEY=\"$ORCA_PANE_KEY\"} \\\n ${ORCA_AGENT_LAUNCH_TOKEN:+ORCA_AGENT_LAUNCH_TOKEN=\"$ORCA_AGENT_LAUNCH_TOKEN\"} \\\n ${ORCA_AGENT_SESSION_ID:+ORCA_AGENT_SESSION_ID=\"$ORCA_AGENT_SESSION_ID\"} \\\n timeout 15 \"$node\" \"$cli\" sender --json 2>/dev/null || true)\"\ndevice=\"$(jq -r '.result.sender.deviceId // empty' <<<\"$answer\" 2>/dev/null || true)\"\nif [ -z \"$device\" ] || [ ! -s \"$DIR/devices.json\" ]; then\n if [ -n \"${ORCA_GIT_AS:-}\" ]; then\n echo \"orca-git-as: Orca cannot confirm that $ORCA_GIT_AS sent this agent's latest message; refusing to push as them.\" >&2\n exit 4\n fi\n exit 3\nfi\nmember=\"$(jq -r --arg d \"$device\" '.[$d] // empty' \"$DIR/devices.json\")\"\nif [ -z \"$member\" ]; then\n [ -n \"${ORCA_GIT_AS:-}\" ] && { echo \"orca-git-as: the sender's device is not linked to a workspace member; refusing.\" >&2; exit 4; }\n exit 3\nfi\nif [ -n \"${ORCA_GIT_AS:-}\" ] && [ \"$ORCA_GIT_AS\" != \"$member\" ]; then\n echo \"orca-git-as: this agent's latest message came from $member, not $ORCA_GIT_AS; refusing to push as someone else.\" >&2\n exit 4\nfi\nfile=\"$DIR/$(printf '%s' \"$member\" | tr ':' '_').gitconfig\"\n[ -s \"$file\" ] || exit 3\n# The caller reads the identity through this one-shot copy (owned by them, removed by orca-git-as).\nout=\"$(sudo -u \"$caller\" mktemp)\"\ncat \"$file\" >\"$out\"\necho \"$out\"\n","orcad-boot":"#!/usr/bin/env node\n// Starts orcad from a V8 code cache taken after a full startup, so a boot skips compiling the\n// functions startup runs. NODE_COMPILE_CACHE only stores what V8 compiles before the bundle runs\n// (about 5 of its 15 MB); every other function compiled lazily on every boot (~300 ms of wake).\n// orcad-boot --code-cache [--write-code-cache] [orcad args...]\n// orcad sees the argv `node [orcad args...]`, as if started directly.\n// --write-code-cache (the image's smoke run) writes the cache when orcad exits. The cache is used\n// only when its header matches this bundle's bytes and this Node; otherwise orcad loads exactly as\n// before (plain require, which NODE_COMPILE_CACHE still serves). Plain Node, no dependencies.\n// getBuiltinModule (Node >= 22.3) works whether node loads this extensionless file as CommonJS\n// (in the VM) or as an ES module (under this repo's type:module package, in tests).\nconst fs = process.getBuiltinModule('node:fs')\nconst path = process.getBuiltinModule('node:path')\nconst vm = process.getBuiltinModule('node:vm')\nconst zlib = process.getBuiltinModule('node:zlib')\nconst { Module, createRequire } = process.getBuiltinModule('node:module')\n\nconst MAGIC = 'orcad-code-cache-v1'\n\nconst args = process.argv.slice(2)\nlet cacheFile = null\nlet writeCache = false\nwhile (args[0] === '--code-cache' || args[0] === '--write-code-cache') {\n if (args[0] === '--code-cache') {\n cacheFile = args[1]\n args.splice(0, 2)\n } else {\n writeCache = true\n args.shift()\n }\n}\nconst entry = args.shift()\nif (!entry || !cacheFile) {\n console.error('usage: orcad-boot --code-cache [--write-code-cache] [args...]')\n process.exit(2)\n}\n// As for `node `: argv[1] is the resolved path, __filename the real one.\nprocess.argv = [process.argv[0], path.resolve(entry), ...args]\nlet file = process.argv[1]\ntry {\n file = fs.realpathSync(file)\n} catch {\n // A missing bundle fails in require below, as it would under plain node.\n}\n\n// One line of identity: a cache from another bundle or Node must never run (V8 only checks length).\nfunction cacheHeader(bytes) {\n return `${MAGIC} ${process.version} ${process.arch} ${bytes.length} ${zlib.crc32(bytes)}\\n`\n}\n\nfunction readCache(header) {\n let data\n try {\n data = fs.readFileSync(cacheFile)\n } catch {\n return null\n }\n const headerLength = Buffer.byteLength(header)\n if (data.length <= headerLength || data.toString('latin1', 0, headerLength) !== header) {\n console.error('orcad-boot: code cache is for another orcad build; loading without it')\n return null\n }\n return data.subarray(headerLength)\n}\n\nfunction runCompiled(header, source, cachedData) {\n // A vm.Script can serialize what startup compiled; the CommonJS loader cannot. Same wrapper,\n // filename and require as the loader, and import() resolves from the bundle like it does there.\n const options = {\n filename: file,\n cachedData: cachedData ?? undefined,\n importModuleDynamically: vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER\n }\n // Node flags the loader option experimental once, on the first import() through it. Spend that\n // one-time warning here, unprinted, so orcad's stderr stays as it was.\n const emitWarning = process.emitWarning\n process.emitWarning = (warning, ...rest) => {\n if (!String(warning?.message ?? warning).includes('USE_MAIN_CONTEXT_DEFAULT_LOADER')) {\n emitWarning.call(process, warning, ...rest)\n }\n }\n let script\n try {\n new vm.Script('import(\"node:path\")', {\n filename: file,\n importModuleDynamically: options.importModuleDynamically\n })\n .runInThisContext()\n .catch(() => {})\n script = new vm.Script(Module.wrap(source), options)\n } finally {\n process.emitWarning = emitWarning\n }\n if (cachedData && script.cachedDataRejected) {\n console.error('orcad-boot: V8 rejected the code cache (other V8 flags?); compiled without it')\n }\n if (writeCache) {\n process.on('exit', () => {\n try {\n const data = script.createCachedData()\n const temporary = `${cacheFile}.${process.pid}.tmp`\n fs.writeFileSync(temporary, Buffer.concat([Buffer.from(header, 'latin1'), data]))\n fs.renameSync(temporary, cacheFile)\n console.error(`orcad-boot: wrote ${data.length} bytes of code cache`)\n } catch (error) {\n console.error(`orcad-boot: could not write the code cache: ${error.message}`)\n }\n })\n }\n const module = new Module(file, null)\n module.filename = file\n module.paths = Module._nodeModulePaths(path.dirname(file))\n const compiled = script.runInThisContext()\n compiled.call(module.exports, module.exports, createRequire(file), module, file, path.dirname(file))\n}\n\n// Locals, so neither the bundle bytes nor the cache outlive the compile.\nfunction boot() {\n // Older Node (no crc32 or main-context import()) loads as before.\n if (typeof zlib.crc32 === 'function' && vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER) {\n let bytes = null\n try {\n bytes = fs.readFileSync(file)\n } catch {\n // Missing or unreadable: require reports it as plain node would.\n }\n if (bytes) {\n const header = cacheHeader(bytes)\n const cachedData = readCache(header)\n if (cachedData || writeCache) {\n runCompiled(header, bytes.toString('utf8'), cachedData)\n return\n }\n }\n }\n createRequire(file)(file)\n}\n\nboot()\n","git":"#!/usr/bin/env bash\n# git for agents in Orca Cloud workspaces (first on orcad's PATH). Commands that author or publish\n# work run as the teammate whose message started this agent's turn (orca-git-as: orcad attests the\n# sender's paired device; root-only member identities). Everything else is plain git, untouched.\nreal=/usr/bin/git\nsub=''\nskip=0\nfor arg in \"$@\"; do\n if [ \"$skip\" = 1 ]; then skip=0; continue; fi\n case \"$arg\" in\n -C | -c | --git-dir | --work-tree | --namespace | --exec-path | --config-env) skip=1 ;;\n -*) ;;\n *) sub=\"$arg\"; break ;;\n esac\ndone\ncase \"$sub\" in\n commit | push | merge | rebase | cherry-pick | revert | am | pull | tag)\n # Outside an agent turn (no attested sender) orca-git-as falls back to the workspace identity.\n if [ -n \"${ORCA_TERMINAL_HANDLE:-}${ORCA_AGENT_SESSION_ID:-}\" ] && [ -x /opt/orca/bin/orca-git-as ]; then\n PATH=\"/usr/bin:/bin:$PATH\" exec /opt/orca/bin/orca-git-as \"$@\" 2> >(grep -v '^orca-git-as: no teammate identity' >&2)\n fi\n ;;\nesac\nexec \"$real\" \"$@\"\n"} +export const VM_SCRIPT_SOURCES: BuildInputs['vmScripts'] = {"orca-sandbox-start":"#!/usr/bin/env bash\n# Starts orcad for this boot (idempotent) and prints its recipe line:\n# {\"schemaVersion\":1,\"pairingCode\":\"orca://pair?...\",\"projectRoot\":\"/vercel/sandbox/project\"}\n# Env from the control plane: ORCA_SANDBOX_ID, ORCA_PUBLIC_WSS, optional ORCA_REPO_URL/ORCA_REPO_REF,\n# ORCA_GITHUB_PLACEHOLDER, ORCA_SECRET_ENV (`NAME=` lines: org/personal/repo secrets for\n# orcad and its agents), ORCA_SHARE_PROXY_KEY (this session's share-link proxy key, port 6769).\n# Never prints anything else on stdout's last line.\n# With ORCA_READY_VIA=file it prints {\"schemaVersion\":1,\"readyFile\":\"\"} instead and the control\n# plane reads the offer with the files API: the provider keeps command stdout as logs, not files.\n# With ORCA_READY_KEY too (64 hex chars, this call's key; env is not kept) the pointer also carries\n# \"sealedOffer\": \".\", which saves that round trip.\n# Managed env for every process orcad starts: ORCA_IS_CLOUD=1, ORCA_SANDBOX_ID, ORCA_ROOT_PATH,\n# ORCA_WORKTREE_PATH, ORCA_WORKSPACE_PATH, ORCA_WORKSPACE_NAME, ORCA_DEFAULT_BRANCH, ORCA_PORT and the\n# CONDUCTOR_* names imported Conductor scripts read.\nset -euo pipefail\numask 077\nORCA_HOME=/opt/orca\nSTATE=\"$HOME/.orca-sandbox\"\nPROJECT=/vercel/sandbox/project\nmkdir -p \"$STATE\"\n# Only print_ready uses the key; nothing this script starts inherits it.\nready_key=\"${ORCA_READY_KEY:-}\"\nunset ORCA_READY_KEY\n[[ \"$ready_key\" =~ ^[0-9a-f]{64}$ ]] || ready_key=''\nexec 9>\"$STATE/start.lock\"\nflock -w 60 9\n# Background children close fd 9 (`9>&-`): an orcad that inherited it would hold the lock for its whole\n# life and every later start (resume of a running sandbox, a retried create) would wait out the 60 s.\n\n# orcad only lists a project once a client registers it (the desktop does on connect), so API, MCP,\n# routine and phone sessions saw no repo. Register the workspace project at every start, in the\n# background (ready is not delayed); `repo add` of an already-registered path is a no-op error.\nregister_project() {\n [ -x \"$ORCA_HOME/bin/orca\" ] && [ -d \"$PROJECT\" ] || return 0\n local kind=() name=()\n [ -e \"$PROJECT/.git\" ] || kind=(--kind folder)\n # The checkout lives at .../project; name it after the repository (owner/name.git -> name).\n if [ -n \"${ORCA_REPO_URL:-}\" ]; then\n local base=\"${ORCA_REPO_URL%/}\"\n base=\"${base##*/}\"\n base=\"${base%.git}\"\n [ -n \"$base\" ] && name=(--display-name \"$base\")\n fi\n setsid \"$ORCA_HOME/bin/orca\" repo add --path \"$PROJECT\" \"${kind[@]}\" \"${name[@]}\" --json \\\n >\"$STATE/register-project.log\" 2>&1 &- &\n}\n\nprint_ready() {\n if [ \"${ORCA_READY_VIA:-}\" = file ]; then\n local sealed='' iv\n if [ -n \"$ready_key\" ] && command -v openssl >/dev/null; then\n iv=\"$(od -An -N16 -tx1 /dev/urandom | tr -d ' \\n')\"\n # Best effort: without it the control plane reads the file, as before.\n sealed=\"$(tail -n 1 \"$STATE/ready.json\" | openssl enc -aes-256-ctr -K \"$ready_key\" -iv \"$iv\" -nosalt | base64 -w0)\" &&\n sealed=\"$iv.$sealed\" || sealed=''\n fi\n printf '{\"schemaVersion\":1,\"readyFile\":\"%s\"%s}\\n' \"$STATE/ready.json\" \"${sealed:+,\\\"sealedOffer\\\":\\\"$sealed\\\"}\"\n else\n tail -n 1 \"$STATE/ready.json\"\n fi\n}\n# Command stderr is kept by the provider: strip injected values and credential shapes from log tails.\nredact_log() {\n local text kv value\n text=\"$(cat)\"\n for kv in ${agent_env[@]+\"${agent_env[@]}\"}; do\n value=\"${kv#*=}\"\n if [ \"${#value}\" -ge 8 ]; then\n text=\"${text//\"$value\"/[REDACTED]}\"\n fi\n done\n printf '%s\\n' \"$text\" | sed -E \\\n -e 's#orca://[^[:space:]]+#[REDACTED_PAIRING]#g' \\\n -e 's#(gh[pousr]_|github_pat_|sk-|vc[kpiar]_)[A-Za-z0-9._-]{16,}#[REDACTED_TOKEN]#g' \\\n -e 's#eyJ[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}\\.[A-Za-z0-9_-]{8,}#[REDACTED_JWT]#g' \\\n -e 's#(Authorization|authorization):[[:space:]]*[A-Za-z]+[[:space:]]+[^[:space:]]+#\\1: [REDACTED]#g'\n}\n\nnode=\"$(find \"$ORCA_HOME/runtime/runtimes\" -type f -name node | head -n 1)\"\n\n# Share-link proxy (port 6769): answers only requests the control plane signed with this session's\n# key, so its public route is useless on its own. The key goes in on stdin (printf is a builtin), so\n# it never appears in any argv or in the proxy's /proc//environ.\nstart_share_proxy() {\n [ -n \"${ORCA_SHARE_PROXY_KEY:-}\" ] && [ -x \"$ORCA_HOME/bin/orca-share-proxy\" ] || return 0\n if [ \"$(cat \"$STATE/share-proxy.boot\" 2>/dev/null || true)\" = \"$boot_id\" ] \\\n && kill -0 \"$(cat \"$STATE/share-proxy.pid\" 2>/dev/null || echo 0)\" 2>/dev/null; then\n return 0\n fi\n printf '%s' \"$ORCA_SHARE_PROXY_KEY\" | env -i HOME=\"$HOME\" LANG=C.UTF-8 PATH=/usr/bin:/bin \\\n setsid \"$node\" \"$ORCA_HOME/bin/orca-share-proxy\" >\"$STATE/share-proxy.log\" 2>&1 9>&- &\n echo $! >\"$STATE/share-proxy.pid\"\n printf '%s' \"$boot_id\" >\"$STATE/share-proxy.boot\"\n}\n\nboot_id=\"$(cat /proc/sys/kernel/random/boot_id)\"\nstart_share_proxy\nunset ORCA_SHARE_PROXY_KEY\nif [ \"$(cat \"$STATE/boot-id\" 2>/dev/null || true)\" = \"$boot_id\" ] && [ -s \"$STATE/ready.json\" ] \\\n && kill -0 \"$(cat \"$STATE/orcad.pid\" 2>/dev/null || echo 0)\" 2>/dev/null; then\n print_ready\n exit 0\nfi\n# Resume = reboot from disk: locks and pids from the previous session name dead processes.\nrm -f \"$STATE/ready.json\" \"$STATE/orcad.pid\"\nprintf '%s' \"$boot_id\" >\"$STATE/boot-id\"\n\nif [ -n \"${ORCA_GIT_EXTRAHEADER:-}\" ]; then\n # Every github.com request carries the placeholder; the egress policy swaps in a 1h repo token.\n git config --global http.https://github.com/.extraheader \"$ORCA_GIT_EXTRAHEADER\"\nfi\n# Commits outside a teammate's turn (or before any member connected GitHub) need an author too.\ngit config --global user.email >/dev/null 2>&1 || git config --global user.email 'cloud@users.noreply.onorca.dev'\ngit config --global user.name >/dev/null 2>&1 || git config --global user.name 'Orca Cloud'\n# First boot clones while orcad starts (orcad only needs the directory to exist); ready waits for both.\nclone_pid=''\nif [ ! -d \"$PROJECT\" ]; then\n mkdir -p \"$PROJECT\"\n if [ -n \"${ORCA_REPO_URL:-}\" ]; then\n git clone --quiet ${ORCA_REPO_REF:+--branch \"$ORCA_REPO_REF\"} -- \"$ORCA_REPO_URL\" \"$PROJECT\" 2>\"$STATE/clone.log\" 9>&- &\n clone_pid=$!\n fi\nfi\n\n# The clone may still be running here, so the name comes from the URL; the default branch is\n# filled in lazily by the session-env shell hook once the clone exists.\nif [ -n \"${ORCA_REPO_URL:-}\" ]; then\n workspace_name=\"$(basename \"${ORCA_REPO_URL%/}\" .git)\"\nelse\n workspace_name=\"$(basename \"$(git -C \"$PROJECT\" remote get-url origin 2>/dev/null || echo \"$PROJECT\")\" .git)\"\nfi\n# One workspace per VM: its preview ports start at 3000 (Conductor allots CONDUCTOR_PORT..+9).\nmanaged_env=(\n ORCA_IS_CLOUD=1\n ORCA_ROOT_PATH=\"$PROJECT\" ORCA_WORKTREE_PATH=\"$PROJECT\" ORCA_WORKSPACE_PATH=\"$PROJECT\"\n ORCA_WORKSPACE_NAME=\"$workspace_name\" ORCA_PORT=3000\n CONDUCTOR_IS_CLOUD=1\n # Agent CLIs are pinned by the image (smoke-tested); a self-update mid-session can break a running agent.\n DISABLE_AUTOUPDATER=1 OPENCODE_DISABLE_AUTOUPDATE=1 COPILOT_AUTO_UPDATE=false\n CONDUCTOR_ROOT_PATH=\"$PROJECT\" CONDUCTOR_WORKSPACE_PATH=\"$PROJECT\"\n CONDUCTOR_WORKSPACE_NAME=\"$workspace_name\" CONDUCTOR_PORT=3000\n)\n\nagent_env=()\nif command -v google-chrome >/dev/null; then\n # Orca's browser automation and agent browser tools use the image's headless Chrome.\n agent_env+=(\"ORCA_BROWSER_EXECUTABLE=$(command -v google-chrome)\")\nfi\nif [ -n \"${ORCA_GITHUB_PLACEHOLDER:-}\" ]; then\n # The egress layer swaps the placeholder for a short-lived GitHub token; none lives in the VM.\n agent_env+=(\"GH_TOKEN=$ORCA_GITHUB_PLACEHOLDER\" \"GITHUB_TOKEN=$ORCA_GITHUB_PLACEHOLDER\")\nfi\n\nsecret_names=()\nif [ -n \"${ORCA_SECRET_ENV:-}\" ]; then\n # Secrets live only in memory: orcad's process env and a tmpfs file new shells re-read\n # (orca-sandbox-env), never under $HOME or the project, so the stop snapshot never carries them.\n # Resolved per start (and per edit) by the control plane: no image rebuild, no restart.\n while IFS= read -r line; do\n name=\"${line%%=*}\" b64=\"${line#*=}\" # not IFS='=': read would strip base64 padding\n case \"$name\" in '' | *[!A-Z0-9_]* | [0-9]* | ORCA_* | PATH | HOME | LD_* | DYLD_*) continue ;; esac\n agent_env+=(\"$name=$(printf '%s' \"$b64\" | base64 -d)\")\n secret_names+=(\"$name\")\n done < <(printf '%s\\n' \"$ORCA_SECRET_ENV\") # a pipe, not a here-string temp file\nfi\n# Always rewrite the file, so a resume with fewer secrets drops the old names too.\n\"$ORCA_HOME/bin/orca-sandbox-env\" >/dev/null || echo 'session env file unavailable; secrets apply at boot only' >&2\nunset ORCA_SECRET_ENV\n\n# Agent CLIs installed with the image's npm (codex, gemini, ...) are `#!/usr/bin/env node` scripts:\n# terminals need that node on PATH, not only orcad's bundled runtime.\nsystem_node=\"$(command -v node 2>/dev/null || echo \"$node\")\"\n# The egress proxy answers for hosts with credential rules (model APIs, api.github.com) with a\n# certificate from Vercel's CA, which this command's env trusts (Vercel sets these). Pure-Node clients\n# use Node's bundled roots otherwise: Gemini CLI retried forever (\"taking a bit longer\") in every\n# terminal while the same call worked here. Pass the provider's CA settings on to orcad and its shells.\nca_env=(NODE_USE_SYSTEM_CA=\"${NODE_USE_SYSTEM_CA:-1}\")\nfor name in NODE_EXTRA_CA_CERTS SSL_CERT_FILE; do\n if [ -n \"${!name:-}\" ]; then ca_env+=(\"$name=${!name}\"); fi\ndone\n# Ports panel: programs under $ORCA_HOME are the image's own services, and 23456 is Vercel's\n# sandbox-init (root, pid invisible to this user); neither is listed as the user's port.\nenv -i HOME=\"$HOME\" USER=\"$(id -un)\" LANG=C.UTF-8 TERM=xterm-256color \"${ca_env[@]}\" \\\n PATH=\"$ORCA_HOME/tools/bin:$ORCA_HOME/bin:$(dirname \"$system_node\"):/usr/local/bin:/usr/bin:/bin\" \\\n ORCA_USER_DATA=\"$HOME/.orcad-data\" ORCA_SANDBOX_ID=\"$ORCA_SANDBOX_ID\" \"${managed_env[@]}\" \\\n ORCA_HOST_MANAGED_LISTENER_PATHS=\"$ORCA_HOME\" ORCA_HOST_MANAGED_UNOWNED_PORTS=23456 \\\n NODE_COMPILE_CACHE=\"$ORCA_HOME/compile-cache\" ORCA_ORCAD_STARTUP_QUALIFICATION_DIR=\"$ORCA_HOME/startup-qualification\" \\\n ORCA_SESSION_ENV_NAMES=\"${secret_names[*]}\" \"${agent_env[@]}\" \\\n setsid nohup \"$node\" \"$ORCA_HOME/bin/orcad-boot\" --code-cache \"$ORCA_HOME/compile-cache/orcad-server.v8\" \\\n \"$ORCA_HOME/runtime/orcad/orcad-server.js\" --port 6768 --bind 0.0.0.0 --pairing-address \"$ORCA_PUBLIC_WSS\" \\\n --recipe-json --project-root \"$PROJECT\" \\\n >\"$STATE/ready.json\" 2>\"$STATE/orcad.log\" &- &\necho $! >\"$STATE/orcad.pid\"\n\n# sshd for `orca ssh` (loopback only). Best effort: a workspace without it still serves orcad.\n\"$ORCA_HOME/bin/orca-sshd\" >/dev/null 2>\"$STATE/sshd-start.err\" || true\n\n# Polled every 10 ms (at least 60 s in all): ready is on the wake path, so detect it promptly.\nfor _ in $(seq 1 6000); do\n if grep -q '\"pairingCode\"' \"$STATE/ready.json\" 2>/dev/null; then\n if [ -n \"$clone_pid\" ] && ! wait \"$clone_pid\"; then\n echo 'repository clone failed' >&2\n tail -n 5 \"$STATE/clone.log\" | redact_log >&2\n exit 1\n fi\n register_project\n print_ready\n exit 0\n fi\n if ! kill -0 \"$(cat \"$STATE/orcad.pid\")\" 2>/dev/null; then\n echo 'orcad exited before ready' >&2\n tail -n 40 \"$STATE/orcad.log\" | redact_log >&2\n exit 1\n fi\n sleep 0.01\ndone\necho 'orcad start timed out' >&2\nexit 1\n","orca-sandbox-drain":"#!/usr/bin/env bash\n# Asks orcad to quit before the VM stops: its shutdown turns working agent chats into durable\n# restart offers and flushes terminal restore hints, which the desktop continues after resume.\nset -euo pipefail\nSTATE=\"$HOME/.orca-sandbox\"\nWAIT_SECONDS=\"${1:-280}\"\npid=\"$(cat \"$STATE/orcad.pid\" 2>/dev/null || true)\"\nif [ -z \"$pid\" ] || ! kill -0 \"$pid\" 2>/dev/null; then\n exit 0\nfi\nkill -TERM \"$pid\"\nfor _ in $(seq 1 $((WAIT_SECONDS * 10))); do\n if ! kill -0 \"$pid\" 2>/dev/null; then\n rm -f \"$STATE/orcad.pid\" \"$STATE/ready.json\"\n exit 0\n fi\n sleep 0.1\ndone\n# Leave it running: the provider stop ends it, and the drain already had its window.\necho 'orcad still draining at deadline' >&2\nexit 0\n","orca-sandbox-env":"#!/usr/bin/env bash\n# Writes this session's secret env where new shells and agent launches read it (orca-session-env.sh).\n# Input: ORCA_SECRET_ENV (`NAME=` lines) from the control plane, at boot (orca-sandbox-start)\n# and whenever a secret changes (POST /v1/sandboxes/:id/env/refresh). The file lives on tmpfs only:\n# never on the sandbox disk, so the stop snapshot never carries it. Prints {\"names\":N} on success.\n# Also keeps Codex pointed at a configured OpenAI-compatible provider (OPENAI_BASE_URL), since Codex\n# does not read that variable: a managed block in ~/.codex/config.toml naming only the env var.\nset -euo pipefail\numask 077\nHOME=\"${HOME:-$(getent passwd \"$(id -u)\" | cut -d: -f6)}\"\n# ORCA_SESSION_ENV_DIR: tests only (a scratch dir off tmpfs); the control plane never sets it.\ndir=\"${ORCA_SESSION_ENV_DIR:-/dev/shm/orca-env-$(id -u)}\"\nif [ -z \"${ORCA_SESSION_ENV_DIR:-}\" ] && [ \"$(stat -f -c %T /dev/shm 2>/dev/null || true)\" != tmpfs ]; then\n # No memory-only place to keep it: refuse rather than write secrets to disk.\n echo 'no tmpfs for the session env' >&2\n exit 3\nfi\nmkdir -p \"$dir\"\nchmod 700 \"$dir\"\n# Writes are ordered by the control plane's resolve time: an older refresh that lost a race is dropped.\ngeneration=\"${ORCA_ENV_GENERATION:-0}\"\ncase \"$generation\" in '' | *[!0-9]*) generation=0 ;; esac\ncurrent=\"$(cat \"$dir/generation\" 2>/dev/null || echo 0)\"\ncase \"$current\" in '' | *[!0-9]*) current=0 ;; esac\nif [ \"$generation\" -lt \"$current\" ]; then\n printf '{\"stale\":true}\\n'\n exit 0\nfi\ntmp=\"$(mktemp \"$dir/.session.env.XXXXXX\")\"\ncount=0\nopenai_base_url=''\nopenai_model=''\nanthropic_model=''\nanthropic_key_tail=''\ngateway_key=''\ngemini_key=''\ncodex_placeholder=''\nwhile IFS= read -r line; do\n name=\"${line%%=*}\" b64=\"${line#*=}\"\n # Not for shells: the Codex account placeholder becomes ~/.codex/auth.json below.\n if [ \"$name\" = ORCA_CODEX_AUTH_PLACEHOLDER ]; then\n codex_placeholder=\"$(printf '%s' \"$b64\" | base64 -d)\"\n case \"$codex_placeholder\" in *[!A-Za-z0-9._-]*) codex_placeholder='' ;; esac\n fi\n case \"$name\" in '' | *[!A-Z0-9_]* | [0-9]* | ORCA_* | PATH | HOME | LD_* | DYLD_*) continue ;; esac\n # Values stay base64 in the file; the shell hook decodes them.\n printf '%s=%s\\n' \"$name\" \"$b64\" >>\"$tmp\"\n count=$((count + 1))\n case \"$name\" in\n OPENAI_BASE_URL) openai_base_url=\"$(printf '%s' \"$b64\" | base64 -d)\" ;;\n OPENAI_MODEL) openai_model=\"$(printf '%s' \"$b64\" | base64 -d)\" ;;\n ANTHROPIC_MODEL) anthropic_model=\"$(printf '%s' \"$b64\" | base64 -d)\" ;;\n AI_GATEWAY_API_KEY) gateway_key=1 ;;\n GEMINI_API_KEY | GOOGLE_API_KEY) gemini_key=\"${gemini_key:-gemini-api-key}\" ;;\n GOOGLE_GENAI_USE_VERTEXAI) case \"$(printf '%s' \"$b64\" | base64 -d)\" in true | 1) gemini_key=vertex-ai ;; esac ;;\n # Claude Code asks once per key whether to use ANTHROPIC_API_KEY; it remembers the last 20 chars.\n ANTHROPIC_API_KEY) anthropic_key_tail=\"$(printf '%s' \"$b64\" | base64 -d | tail -c 20)\" ;;\n esac\ndone < <(printf '%s\\n' \"${ORCA_SECRET_ENV:-}\")\nmv -f \"$tmp\" \"$dir/session.env\"\nprintf '%s' \"$generation\" >\"$dir/generation\"\n\n# ---- Codex: trust the workspace and use the configured provider (no secret values) ----\nPROJECT=/vercel/sandbox/project\ncodex_config=\"$HOME/.codex/config.toml\"\ntoml_string() { # TOML basic string; the control plane only accepts https URLs and plain model ids\n local value=\"${1//\\\\/\\\\\\\\}\"\n printf '\"%s\"' \"${value//\\\"/\\\\\\\"}\"\n}\nstrip_managed() { # drop the managed blocks and the blank lines written before them (no growth per refresh)\n awk '/^# >>> orca-cloud managed/{skip=1; blank=\"\"} skip{if (/^# <<< orca-cloud managed/) skip=0; next}\n /^[[:space:]]*$/{blank=blank $0 \"\\n\"; next} {printf \"%s\", blank; blank=\"\"; print}' \"$1\"\n}\n# Always managed: an agent launched from the phone or the API has no one to answer Codex's\n# \"trust this folder?\" screen, so the workspace project is trusted up front.\nif true; then\n mkdir -p \"$HOME/.codex\"\n user_part=\"$(mktemp \"$HOME/.codex/.config.XXXXXX\")\"\n if [ -f \"$codex_config\" ]; then strip_managed \"$codex_config\" >\"$user_part\"; fi\n next=\"$(mktemp \"$HOME/.codex/.config.XXXXXX\")\"\n openai_host=\"${openai_base_url#https://}\"\n openai_host=\"${openai_host%%/*}\"\n custom_provider=''\n if [ -n \"$openai_base_url\" ] && [ \"$openai_host\" != api.openai.com ]; then custom_provider=1; fi\n # Top-level keys must precede every table; each is skipped when the user already set it.\n head_keys=\"$(awk '/^\\[/{exit} {print}' \"$user_part\")\"\n has_key() { grep -Eq \"^[[:space:]]*$1[[:space:]]*=\" <<<\"$head_keys\"; }\n {\n printf '# >>> orca-cloud managed (Orca Cloud; edit in Orca settings)\\n'\n # The sandbox is the isolation boundary: Codex's own bwrap sandbox can't start in it (\"Unexpected\n # capabilities\"), and a prompt delivered from the phone or the API has no one to approve commands.\n has_key sandbox_mode || printf 'sandbox_mode = \"danger-full-access\"\\n'\n has_key approval_policy || printf 'approval_policy = \"never\"\\n'\n if [ -n \"$custom_provider\" ]; then\n has_key model_provider || printf 'model_provider = \"orca_cloud\"\\n'\n if [ -n \"$openai_model\" ] && ! has_key model; then\n printf 'model = %s\\n' \"$(toml_string \"$openai_model\")\"\n fi\n elif [ -n \"$codex_placeholder\" ]; then\n has_key model_provider || printf 'model_provider = \"orca_chatgpt\"\\n'\n fi\n printf '# <<< orca-cloud managed\\n'\n cat \"$user_part\"\n if [ -n \"$custom_provider\" ]; then\n printf '\\n# >>> orca-cloud managed provider\\n[model_providers.orca_cloud]\\nname = \"Orca Cloud\"\\n'\n printf 'base_url = %s\\nenv_key = \"OPENAI_API_KEY\"\\nwire_api = \"responses\"\\n' \"$(toml_string \"$openai_base_url\")\"\n printf '# <<< orca-cloud managed\\n'\n elif [ -n \"$codex_placeholder\" ]; then\n # Codex via the Orca account: the ChatGPT backend over HTTPS. Its default Responses WebSocket can't\n # pass the egress proxy, where the placeholder becomes the real token (found live, Codex 0.166).\n printf '\\n# >>> orca-cloud managed provider\\n[model_providers.orca_chatgpt]\\nname = \"OpenAI\"\\n'\n printf 'base_url = \"https://chatgpt.com/backend-api/codex\"\\nwire_api = \"responses\"\\nrequires_openai_auth = true\\nsupports_websockets = false\\n'\n printf '# <<< orca-cloud managed\\n'\n fi\n } >\"$next\"\n if ! grep -qF \"[projects.\\\"$PROJECT\\\"]\" \"$user_part\"; then\n printf '\\n# >>> orca-cloud managed trust\\n[projects.\"%s\"]\\ntrust_level = \"trusted\"\\n# <<< orca-cloud managed\\n' \"$PROJECT\" >>\"$next\"\n fi\n chmod 600 \"$next\"\n mv -f \"$next\" \"$codex_config\"\n rm -f \"$user_part\"\nfi\n# ---- Codex via the person's Orca account (contract D11): a placeholder ChatGPT login, no refresh token.\n# The egress proxy swaps the real access token on chatgpt.com; the real tokens never reach this VM. The\n# marker remembers which placeholder Orca wrote (a clone gets its own), so a login of the person's own\n# (kill-switch fallback, or `codex login` run here) is set aside while the account applies and put back after.\ncodex_auth=\"$HOME/.codex/auth.json\"\ncodex_saved=\"$HOME/.codex/auth.json.orca-saved\"\ncodex_marker=\"$HOME/.codex/.orca-account-placeholder\"\ncodex_ours=''\n# Ours: the marker's placeholder, or any Orca placeholder (all end in `.orca-placeholder`; a real token never does).\nif [ -f \"$codex_auth\" ] && { { [ -f \"$codex_marker\" ] && grep -qF \"\\\"$(cat \"$codex_marker\")\\\"\" \"$codex_auth\"; } || grep -q '\\.orca-placeholder\"' \"$codex_auth\"; }; then\n codex_ours=1\nfi\nif [ -n \"$codex_placeholder\" ]; then\n mkdir -p \"$HOME/.codex\"\n if [ -f \"$codex_auth\" ] && [ -z \"$codex_ours\" ]; then\n # Never overwrite a login already set aside: a second one gets its own name.\n if [ -e \"$codex_saved\" ]; then mv -f \"$codex_auth\" \"$codex_saved.$(date -u +%Y%m%d%H%M%S)\"; else mv -f \"$codex_auth\" \"$codex_saved\"; fi\n fi\n # Marker first: a run cut short after the swap still recognises the file as Orca's.\n printf '%s' \"$codex_placeholder\" >\"$codex_marker\"\n codex_tmp=\"$(mktemp \"$HOME/.codex/.auth.XXXXXX\")\"\n printf '{\\n \"OPENAI_API_KEY\": null,\\n \"tokens\": {\\n \"id_token\": \"%s\",\\n \"access_token\": \"%s\",\\n \"refresh_token\": \"\",\\n \"account_id\": null\\n },\\n \"last_refresh\": \"%s\"\\n}\\n' \\\n \"$codex_placeholder\" \"$codex_placeholder\" \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\" >\"$codex_tmp\"\n chmod 600 \"$codex_tmp\"\n mv -f \"$codex_tmp\" \"$codex_auth\"\nelif [ -f \"$codex_marker\" ] || [ -n \"$codex_ours\" ]; then\n if [ -n \"$codex_ours\" ]; then rm -f \"$codex_auth\"; fi\n rm -f \"$codex_marker\"\n if [ -f \"$codex_saved\" ] && [ ! -f \"$codex_auth\" ]; then mv -f \"$codex_saved\" \"$codex_auth\"; fi\nfi\n# ---- Claude Code, Gemini CLI, Cursor agent, Copilot CLI, OpenCode: first-run screens answered once\n# (Claude: theme picker, folder trust, bypass-mode warning, the \"use this API key?\" question; others:\n# folder trust, auth-method picker, self-update). A prompt delivered from the phone or the API has no one to click\n# through them, and the agent would sit there doing nothing. Merges; never touches credentials.\nnode_bin=\"$(command -v node || find /opt/orca/runtime/runtimes -type f -name node 2>/dev/null | head -n 1)\"\nif [ -n \"$node_bin\" ]; then\n ORCA_PROJECT=\"$PROJECT\" ORCA_KEY_TAIL=\"$anthropic_key_tail\" ORCA_GEMINI_KEY=\"$gemini_key\" \\\n ORCA_GATEWAY_MODEL=\"${gateway_key:+${anthropic_model:-$openai_model}}\" \"$node_bin\" -e '\nconst fs = require(\"fs\"), path = require(\"path\"), os = require(\"os\")\nconst home = os.homedir()\nconst readJson = (file) => { try { const v = JSON.parse(fs.readFileSync(file, \"utf8\")); return v && typeof v === \"object\" && !Array.isArray(v) ? v : {} } catch { return {} } }\nconst write = (file, value) => {\n fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 })\n const tmp = `${file}.orca-${process.pid}`\n fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + \"\\n\", { mode: 0o600 })\n fs.renameSync(tmp, file)\n}\nconst claudeFile = path.join(process.env.CLAUDE_CONFIG_DIR || home, \".claude.json\")\nconst c = readJson(claudeFile)\nconst before = JSON.stringify(c)\nc.hasCompletedOnboarding = true\nc.theme = c.theme || \"dark\"\nc.bypassPermissionsModeAccepted = true\nc.projects = c.projects && typeof c.projects === \"object\" ? c.projects : {}\nconst p = process.env.ORCA_PROJECT\nc.projects[p] = { ...(c.projects[p] || {}), hasTrustDialogAccepted: true, hasCompletedProjectOnboarding: true }\nconst tail = process.env.ORCA_KEY_TAIL\nif (tail) {\n const r = c.customApiKeyResponses && typeof c.customApiKeyResponses === \"object\" ? c.customApiKeyResponses : {}\n const approved = Array.isArray(r.approved) ? r.approved : []\n const rejected = Array.isArray(r.rejected) ? r.rejected.filter((t) => t !== tail) : []\n c.customApiKeyResponses = { ...r, approved: approved.includes(tail) ? approved : [...approved, tail], rejected }\n}\nif (JSON.stringify(c) !== before) write(claudeFile, c)\nconst settingsFile = path.join(home, \".claude\", \"settings.json\")\nconst s = readJson(settingsFile)\nif (s.skipDangerousModePermissionPrompt !== true) write(settingsFile, { ...s, skipDangerousModePermissionPrompt: true })\n\n// Each block below only fills in what is unset and leaves a file it cannot parse alone.\nconst readStrict = (file) => { try { return fs.existsSync(file) ? JSON.parse(fs.readFileSync(file, \"utf8\")) : {} } catch { return null } }\nconst isObject = (v) => v !== null && typeof v === \"object\" && !Array.isArray(v)\nconst section = (o, key) => (isObject(o[key]) ? o[key] : (o[key] = {}))\n\n// Gemini CLI: folder trust and the auth-method picker (only when a Gemini key is configured; a\n// Google sign-in picks its own method), no self-update, no usage stats (its host is not on the\n// egress allowlist, so every send would fail).\nconst geminiTrustFile = path.join(home, \".gemini\", \"trustedFolders.json\")\nconst geminiTrust = readStrict(geminiTrustFile)\nif (isObject(geminiTrust) && !geminiTrust[p]) write(geminiTrustFile, { ...geminiTrust, [p]: \"TRUST_FOLDER\" })\nconst geminiSettingsFile = path.join(home, \".gemini\", \"settings.json\")\nconst g = readStrict(geminiSettingsFile)\nif (isObject(g)) {\n const gBefore = JSON.stringify(g)\n const general = section(g, \"general\")\n general.disableAutoUpdate ??= true\n general.disableUpdateNag ??= true\n section(g, \"privacy\").usageStatisticsEnabled ??= false\n // gemini-api-key or vertex-ai (GOOGLE_GENAI_USE_VERTEXAI=true with an API key): headless runs\n // refuse to start without a method (\"Invalid auth method selected\").\n if (process.env.ORCA_GEMINI_KEY) section(section(g, \"security\"), \"auth\").selectedType ??= process.env.ORCA_GEMINI_KEY\n if (JSON.stringify(g) !== gBefore) write(geminiSettingsFile, g)\n}\n\n// Cursor agent: trust the workspace (cursor-agent keys trust by a slug of the path) and pin the\n// release channel to \"static\", which turns off its background self-update.\nconst cursorTrust = path.join(home, \".cursor\", \"projects\", p.replace(/^\\/+/, \"\").replace(/[^A-Za-z0-9]+/g, \"-\"), \".workspace-trusted\")\nif (!fs.existsSync(cursorTrust)) {\n fs.mkdirSync(path.dirname(cursorTrust), { recursive: true, mode: 0o700 })\n fs.writeFileSync(cursorTrust, JSON.stringify({ trustedAt: new Date().toISOString(), workspacePath: p }, null, 2) + \"\\n\", { mode: 0o600 })\n}\nconst cursorConfigFile = path.join(home, \".cursor\", \"cli-config.json\")\nconst cc = readStrict(cursorConfigFile)\nif (isObject(cc) && cc.channel === undefined) write(cursorConfigFile, { version: 1, ...cc, channel: \"static\" })\n\n// GitHub Copilot CLI: trusted folders live in ~/.copilot/config.json, which Copilot prefixes with\n// \"//\" comment lines; keep them.\nconst copilotFile = path.join(home, \".copilot\", \"config.json\")\nlet copilotHead = \"\"\nlet co = {}\ntry {\n const raw = fs.existsSync(copilotFile) ? fs.readFileSync(copilotFile, \"utf8\") : \"\"\n const lines = raw.split(\"\\n\")\n let i = 0\n while (i < lines.length && /^\\s*\\/\\//.test(lines[i])) i++\n copilotHead = lines.slice(0, i).map((l) => l + \"\\n\").join(\"\")\n const body = lines.slice(i).join(\"\\n\").trim()\n co = body ? JSON.parse(body) : {}\n} catch { co = null }\nif (isObject(co)) {\n const folders = Array.isArray(co.trustedFolders) ? co.trustedFolders : []\n if (!folders.includes(p)) {\n fs.mkdirSync(path.dirname(copilotFile), { recursive: true, mode: 0o700 })\n const tmp = `${copilotFile}.orca-${process.pid}`\n fs.writeFileSync(tmp, copilotHead + JSON.stringify({ ...co, trustedFolders: [...folders, p] }, null, 2) + \"\\n\", { mode: 0o600 })\n fs.renameSync(tmp, copilotFile)\n }\n}\n\n// OpenCode: with the AI Gateway preset and a model secret (ANTHROPIC_MODEL, else OPENAI_MODEL), use\n// that model through the gateway unless the user picked one. A ledger remembers what Orca wrote, so a\n// changed model secret updates it and a model the user set is never touched.\nconst ocDir = path.join(home, \".config\", \"opencode\")\nconst ocFile = path.join(ocDir, \"opencode.json\")\nconst ocLedger = path.join(ocDir, \".orca-managed-model\")\nconst managedModel = process.env.ORCA_GATEWAY_MODEL ? `vercel/${process.env.ORCA_GATEWAY_MODEL}` : \"\"\nconst oc = readStrict(ocFile)\nlet jsoncHasModel = false\ntry { jsoncHasModel = /\"model\"\\s*:/.test(fs.readFileSync(path.join(ocDir, \"opencode.jsonc\"), \"utf8\")) } catch {}\nif (isObject(oc) && !jsoncHasModel) {\n let ours = \"\"\n try { ours = fs.readFileSync(ocLedger, \"utf8\").trim() } catch {}\n const userModel = typeof oc.model === \"string\" && oc.model !== ours\n if (!userModel && (oc.model ?? \"\") !== managedModel) {\n const next = { $schema: \"https://opencode.ai/config.json\", ...oc }\n if (managedModel) next.model = managedModel\n else delete next.model\n write(ocFile, next)\n }\n if (!userModel) {\n if (managedModel) fs.writeFileSync(ocLedger, managedModel + \"\\n\", { mode: 0o600 })\n else fs.rmSync(ocLedger, { force: true })\n }\n}\n\n// OpenCode: two built-in providers cannot work in Orca Cloud, and with no other credential OpenCode\n// picks one and fails (\"Authorization header is badly formatted\" / opencode.ai unreachable) instead\n// of showing \"Connect a provider\". GitHub Copilot reads GITHUB_TOKEN, which here is the stand-in for the\n// GitHub App token of the workspace, never a Copilot token; OpenCode Zen needs opencode.ai, which is not on the\n// egress allowlist. Both stay off unless the user connected them in OpenCode itself (auth.json).\nconst ocAuth = readStrict(path.join(process.env.XDG_DATA_HOME || path.join(home, \".local\", \"share\"), \"opencode\", \"auth.json\"))\nconst connected = new Set(isObject(ocAuth) ? Object.keys(ocAuth) : [])\nconst ocDisabledLedger = path.join(ocDir, \".orca-managed-disabled-providers\")\nconst ocNow = readStrict(ocFile)\nif (isObject(ocNow) && !/\"disabled_providers\"\\s*:/.test((() => { try { return fs.readFileSync(path.join(ocDir, \"opencode.jsonc\"), \"utf8\") } catch { return \"\" } })())) {\n let ours = []\n try { ours = fs.readFileSync(ocDisabledLedger, \"utf8\").split(\"\\n\").filter(Boolean) } catch {}\n const userList = (Array.isArray(ocNow.disabled_providers) ? ocNow.disabled_providers : []).filter((id) => typeof id === \"string\" && !ours.includes(id))\n const managed = [\"github-copilot\", \"opencode\"].filter((id) => !connected.has(id) && !userList.includes(id))\n const next = [...userList, ...managed]\n const before = JSON.stringify(ocNow.disabled_providers ?? [])\n if (JSON.stringify(next) !== before) {\n const updated = { $schema: \"https://opencode.ai/config.json\", ...ocNow }\n if (next.length > 0) updated.disabled_providers = next\n else delete updated.disabled_providers\n write(ocFile, updated)\n }\n if (managed.length > 0) fs.writeFileSync(ocDisabledLedger, managed.join(\"\\n\") + \"\\n\", { mode: 0o600 })\n else fs.rmSync(ocDisabledLedger, { force: true })\n}\n' || echo 'agent first-run state not seeded' >&2\nfi\nprintf '{\"names\":%d}\\n' \"$count\"\n","orca-session-env.sh":"# Orca Cloud: sourced by every new bash/zsh (via /etc/profile.d) so terminals and agents started\n# after a secret edit get the current values with no restart. The file is written by\n# /opt/orca/bin/orca-sandbox-env on tmpfs; names it no longer lists are unset. Cloud secrets win\n# over same-named values already in the environment.\n__orca_env_file=\"/dev/shm/orca-env-$(id -u 2>/dev/null)/session.env\"\nif [ -r \"$__orca_env_file\" ]; then\n # $(...) word-splits in both bash and zsh.\n for __orca_n in $(printf '%s' \"${ORCA_SESSION_ENV_NAMES-}\"); do\n unset \"$__orca_n\" 2>/dev/null || true\n done\n __orca_names=''\n while IFS= read -r __orca_line || [ -n \"$__orca_line\" ]; do\n __orca_n=\"${__orca_line%%=*}\"\n case \"$__orca_n\" in '' | *[!A-Z0-9_]* | [0-9]* | ORCA_* | PATH | HOME | LD_* | DYLD_*) continue ;; esac\n export \"$__orca_n=$(printf '%s' \"${__orca_line#*=}\" | base64 -d 2>/dev/null)\"\n __orca_names=\"$__orca_names $__orca_n\"\n done <\"$__orca_env_file\"\n export ORCA_SESSION_ENV_NAMES=\"${__orca_names# }\"\nfi\n# Default branch of the cloud workspace repo, once its first-boot clone exists (computed once per shell tree).\nif [ -n \"${ORCA_WORKSPACE_PATH-}\" ] && [ -z \"${ORCA_DEFAULT_BRANCH-}\" ]; then\n __orca_branch=\"$(git -C \"$ORCA_WORKSPACE_PATH\" symbolic-ref --quiet --short refs/remotes/origin/HEAD 2>/dev/null || true)\"\n if [ -n \"$__orca_branch\" ]; then\n export ORCA_DEFAULT_BRANCH=\"${__orca_branch#origin/}\" CONDUCTOR_DEFAULT_BRANCH=\"${__orca_branch#origin/}\"\n fi\nfi\nunset __orca_env_file __orca_line __orca_n __orca_names __orca_branch\n","orca-env":"#!/usr/bin/env bash\n# Prints shell lines that bring the current shell up to date with this session's cloud env (secrets\n# saved after the shell started): eval \"$(orca-env)\" or, in fish: orca-env --fish | source\n# Reads /dev/shm/orca-env-/session.env (written by orca-sandbox-env, `NAME=` lines) and\n# prints an export for each name, plus an unset for each name in $ORCA_SESSION_ENV_NAMES that is gone.\n# Never writes a file. Values are single-quoted, so quotes, newlines and $ in them stay literal.\nset -euo pipefail\nfish=''\ncase \"${1-}\" in\n '') ;;\n --fish) fish=1 ;;\n -h | --help)\n printf 'usage: eval \"$(orca-env)\" (fish: orca-env --fish | source)\\n'\n exit 0\n ;;\n *)\n printf 'orca-env: unknown option %s\\n' \"$1\" >&2\n exit 2\n ;;\nesac\n# ORCA_SESSION_ENV_FILE is for tests; secrets can't set ORCA_* names.\nfile=\"${ORCA_SESSION_ENV_FILE:-/dev/shm/orca-env-$(id -u)/session.env}\"\nset -f # names are split below, never globbed\n# Not written yet (or not a cloud VM): nothing to change, like the shell hook.\n[ -r \"$file\" ] || exit 0\n\n# 'it'\\''s' for POSIX shells; fish single quotes escape only \\ and '.\nquote() {\n local v=\"$1\"\n if [ -n \"$fish\" ]; then\n v=\"${v//\\\\/\\\\\\\\}\"\n v=\"${v//\\'/\\\\\\'}\"\n printf \"'%s'\" \"$v\"\n else\n printf \"'%s'\" \"${v//\\'/\\'\\\\\\'\\'}\"\n fi\n}\n\n# The control plane's reserved names and prefixes (cloud/apps/sandbox-control/src/secrets.ts; a test\n# keeps this in sync): a session file never sets what would hijack the shell or Orca's own processes.\nskip_name() {\n case \"$1\" in\n '' | *[!A-Z0-9_]* | [0-9]*) return 0 ;;\n LD_* | DYLD_* | ORCA_* | VERCEL_* | BASH_FUNC_* | GIT_CONFIG*) return 0 ;;\n PATH | HOME | USER | LOGNAME | SHELL | PWD | OLDPWD | LANG | TERM | TMPDIR | IFS | ENV | \\\n BASH_ENV | PS4 | PROMPT_COMMAND | SHELLOPTS | BASHOPTS | NODE_OPTIONS | NODE_PATH | \\\n NODE_EXTRA_CA_CERTS | NODE_TLS_REJECT_UNAUTHORIZED | SSL_CERT_FILE | SSL_CERT_DIR | \\\n CURL_CA_BUNDLE | REQUESTS_CA_BUNDLE | HTTP_PROXY | HTTPS_PROXY | ALL_PROXY | NO_PROXY | \\\n PYTHONPATH | PYTHONSTARTUP | PERL5OPT | RUBYOPT | JAVA_TOOL_OPTIONS | GIT_SSH | \\\n GIT_SSH_COMMAND | GIT_ASKPASS | GIT_EXEC_PATH | GIT_PROXY_COMMAND | SSH_AUTH_SOCK | \\\n GH_TOKEN | GITHUB_TOKEN) return 0 ;;\n # CLAUDE_CODE_OAUTH_TOKEN is reserved for users but set by the control plane itself: only ever the\n # Orca-account placeholder (contract D10), never a stored value.\n esac\n return 1\n}\n\nnames=' '\nwhile IFS= read -r line || [ -n \"$line\" ]; do\n name=\"${line%%=*}\"\n skip_name \"$name\" && continue\n # $(...) drops trailing newlines; the x keeps them.\n value=\"$(printf '%s' \"${line#*=}\" | base64 -d 2>/dev/null; printf x)\"\n value=\"${value%x}\"\n if [ -n \"$fish\" ]; then\n printf 'set -gx %s %s\\n' \"$name\" \"$(quote \"$value\")\"\n else\n printf 'export %s=%s\\n' \"$name\" \"$(quote \"$value\")\"\n fi\n names=\"$names$name \"\ndone <\"$file\"\nfor name in ${ORCA_SESSION_ENV_NAMES-}; do\n skip_name \"$name\" && continue\n case \"$names\" in *\" $name \"*) continue ;; esac\n if [ -n \"$fish\" ]; then\n printf 'set -e %s\\n' \"$name\"\n else\n printf 'unset %s\\n' \"$name\"\n fi\ndone\nnames=\"${names# }\"\nnames=\"${names% }\"\nif [ -n \"$fish\" ]; then\n printf 'set -gx ORCA_SESSION_ENV_NAMES %s\\n' \"$(quote \"$names\")\"\nelse\n printf 'export ORCA_SESSION_ENV_NAMES=%s\\n' \"$(quote \"$names\")\"\nfi\n","orca-egress-probe":"#!/usr/bin/env bash\n# Bounded Node fetch against each credential host. Vercel transform rules have made undici hang on\n# response bodies (no content-length / transfer-encoding); report it instead of letting agents hang.\n# Prints one JSON line: {\"host\":\"api.github.com\",\"status\":\"ok\"|\"egress_framing_hang\"|\"error\"}.\nset -euo pipefail\nnode=\"$(find /opt/orca/runtime/runtimes -type f -name node | head -n 1)\"\nfor host in \"$@\"; do\n \"$node\" -e '\n const host = process.argv[1]\n const timer = setTimeout(() => { console.log(JSON.stringify({ host, status: \"egress_framing_hang\" })); process.exit(0) }, 8000)\n fetch(`https://${host}/`, { headers: { authorization: process.env.ORCA_PROBE_AUTHORIZATION ?? \"\" } })\n .then((r) => r.arrayBuffer())\n .then(() => { clearTimeout(timer); console.log(JSON.stringify({ host, status: \"ok\" })) })\n .catch(() => { clearTimeout(timer); console.log(JSON.stringify({ host, status: \"error\" })) })\n ' \"$host\"\ndone\n","orca-image-wipe":"#!/usr/bin/env bash\n# Runs last before the golden snapshot. Every sandbox cloned from the image must start without an\n# orcad identity, device registry, agent sign-in or shell history (clone-safe identity, risk #1).\nset -euo pipefail\npkill -f orcad-server.js 2>/dev/null || true\nfor path in \\\n \"$HOME/.orcad-data\" \"$HOME/.orca-sandbox\" \"$HOME/.orca-desktop\" \"$HOME/.config/orca\" \"$HOME/.config/orca-dev\" \\\n \"$HOME/.claude\" \"$HOME/.claude.json\" \"$HOME/.codex\" \"$HOME/.config/gh\" \"$HOME/.gemini\" \\\n \"$HOME/.local/share/opencode\" \"$HOME/.config/opencode\" \"$HOME/.cursor\" \"$HOME/.config/cursor\" \\\n \"$HOME/.local/share/cursor-agent\" \"$HOME/.copilot\" \"$HOME/.npm\" \"$HOME/.cache\" \"$HOME/.config/google-chrome\" \"$HOME/.bash_history\" \\\n /vercel/sandbox/project; do\n rm -rf -- \"$path\"\ndone\nsudo rm -rf /tmp/* /var/tmp/* 2>/dev/null || true\nfor leftover in \"$HOME/.orcad-data\" \"$HOME/.claude\" \"$HOME/.codex\" \"$HOME/.config/gh\" \"$HOME/.cursor\" \"$HOME/.copilot\" \"$HOME/.gemini\"; do\n if [ -e \"$leftover\" ]; then\n echo \"identity survived wipe: $leftover\" >&2\n exit 1\n fi\ndone\necho '{\"wiped\":true}'\n","orca-agent-signout":"#!/usr/bin/env bash\n# Signs every agent out on this sandbox before Orca deletes it (A9): each agent's own logout, then\n# its credential files. Covers logins made inside the sandbox (the kill-switch fallback path).\n# Never fails: the sandbox is deleted next whatever happens. Values are never printed.\nset -u\nHOME=\"${HOME:-$(getent passwd \"$(id -u)\" | cut -d: -f6)}\"\nexport PATH=\"/opt/orca/tools/bin:$HOME/.local/bin:$HOME/.npm-global/bin:/usr/local/bin:/usr/bin:/bin:/opt/orca/bin:${PATH:-}\"\nclaude_dir=\"${CLAUDE_CONFIG_DIR:-$HOME/.claude}\"\nclaude_json=\"${CLAUDE_CONFIG_DIR:-$HOME}/.claude.json\"\ncodex_dir=\"${CODEX_HOME:-$HOME/.codex}\"\n\nlogged_out=0\n# Each logout gets a few seconds; a hung CLI must not hold up the delete.\nif command -v claude >/dev/null 2>&1 && timeout 8 claude auth logout /dev/null 2>&1; then\n logged_out=$((logged_out + 1))\nfi\nif command -v codex >/dev/null 2>&1 && timeout 8 codex logout /dev/null 2>&1; then\n logged_out=$((logged_out + 1))\nfi\n\n# The files go whether or not a logout ran: an older CLI, a missing binary or no network leaves them.\nrm -f -- \"$claude_dir\"/.credentials* \"$HOME/.claude\"/.credentials* \"$codex_dir/auth.json\" \"$HOME/.codex/auth.json\" 2>/dev/null\n# Orca-managed Codex homes keep their own auth.json under orcad's data dir.\nif [ -d \"$HOME/.orcad-data\" ]; then\n find \"$HOME/.orcad-data\" -path '*codex*' -type f -name auth.json -delete 2>/dev/null\nfi\n# ~/.claude.json keeps settings Orca wrote (onboarding, trust); only the sign-in fields go.\nnode_bin=\"$(command -v node || find /opt/orca/runtime/runtimes -type f -name node 2>/dev/null | head -n 1)\"\nfor file in \"$claude_json\" \"$HOME/.claude.json\"; do\n [ -f \"$file\" ] || continue\n if [ -n \"$node_bin\" ]; then\n ORCA_FILE=\"$file\" \"$node_bin\" -e '\nconst fs = require(\"fs\")\nconst file = process.env.ORCA_FILE\nlet c\ntry { c = JSON.parse(fs.readFileSync(file, \"utf8\")) } catch { process.exit(2) }\nif (!c || typeof c !== \"object\" || Array.isArray(c)) process.exit(2)\nlet changed = false\nfor (const key of Object.keys(c)) {\n if (/oauth/i.test(key) || key === \"primaryApiKey\") { delete c[key]; changed = true }\n}\nif (changed) {\n const tmp = `${file}.orca-${process.pid}`\n fs.writeFileSync(tmp, JSON.stringify(c, null, 2) + \"\\n\", { mode: 0o600 })\n fs.renameSync(tmp, file)\n}\n' 2>/dev/null || rm -f -- \"$file\"\n else\n # No node to edit it safely: losing Orca's settings beats leaving a sign-in behind.\n rm -f -- \"$file\"\n fi\ndone\n\nleft=0\nfor file in \"$claude_dir\"/.credentials* \"$HOME/.claude\"/.credentials* \"$codex_dir/auth.json\" \"$HOME/.codex/auth.json\"; do\n [ -e \"$file\" ] && left=$((left + 1))\ndone\nprintf '{\"loggedOut\":%d,\"left\":%d}\\n' \"$logged_out\" \"$left\"\n","orca-share-proxy":"#!/usr/bin/env node\n// Share-link proxy for this VM. Listens on 0.0.0.0:6769 (its public *.vercel.run route) and only\n// serves requests the control plane's share gateway signed with this session's key:\n// x-orca-share: v2.....\n// A request must start before `expiresAt` (60s windows); its response or WebSocket is closed at\n// `until` (the link's expiry, at most 30 minutes out), so a revoked or expired link also loses open\n// streams. Signed requests are reverse-proxied to 127.0.0.1:: streaming both ways, no\n// buffering, WebSocket upgrades piped raw. Anything unsigned gets a bare 404.\n// The key arrives on stdin (orca-sandbox-start pipes it), so it is never in this process's\n// environment or argv; ORCA_SHARE_PROXY_KEY in the env is accepted for tests. Optional\n// ORCA_SHARE_PROXY_PORT (default 6769). Plain Node, no dependencies.\n// getBuiltinModule (Node >= 22.3) works whether node loads this extensionless file as CommonJS\n// (in the VM) or as an ES module (under this repo's type:module package, in tests).\nconst crypto = process.getBuiltinModule('node:crypto')\nconst fs = process.getBuiltinModule('node:fs')\nconst http = process.getBuiltinModule('node:http')\nconst net = process.getBuiltinModule('node:net')\n\nconst LISTEN_PORT = Number(process.env.ORCA_SHARE_PROXY_PORT || 6769)\nconst KEY = Buffer.from((process.env.ORCA_SHARE_PROXY_KEY || fs.readFileSync(0, 'utf8')).trim(), 'base64url')\ndelete process.env.ORCA_SHARE_PROXY_KEY\n// Never proxy to the VM's sshd, orcad or this proxy itself.\n// 6080: the remote desktop (VNC behind a password) is for its owner's forward only.\nconst BLOCKED_PORTS = new Set([2222, 6080, 6768, LISTEN_PORT])\nconst MAX_SKEW_SECONDS = 300\nconst MAX_CONNECTION_SECONDS = 3600\nconst HOP_BY_HOP = ['connection', 'keep-alive', 'proxy-connection', 'transfer-encoding', 'te', 'trailer', 'upgrade']\n\nif (KEY.length < 32) {\n console.error('orca-share-proxy: share proxy key missing or short')\n process.exit(2)\n}\n\n/** The target port and close-by time (ms) for a validly signed request, else null. */\nfunction verify(header, nowMs) {\n if (typeof header !== 'string') {\n return null\n }\n const match = /^v2\\.(\\d{1,5})\\.(\\d{1,12})\\.(\\d{1,12})\\.([0-9a-f]{32})\\.([A-Za-z0-9_-]{43})$/.exec(header)\n if (!match) {\n return null\n }\n const now = Math.floor(nowMs / 1000)\n const port = Number(match[1])\n const expiresAt = Number(match[2])\n const until = Number(match[3])\n if (port < 1 || port > 65535 || BLOCKED_PORTS.has(port)) {\n return null\n }\n if (expiresAt < now || expiresAt > now + MAX_SKEW_SECONDS || until <= now || until > now + MAX_CONNECTION_SECONDS) {\n return null\n }\n const signed = header.slice(0, header.lastIndexOf('.'))\n const expected = crypto.createHmac('sha256', KEY).update(signed).digest()\n const given = Buffer.from(match[5], 'base64url')\n return given.length === expected.length && crypto.timingSafeEqual(given, expected) ? { port, untilMs: until * 1000 } : null\n}\n\nfunction upstreamHeaders(raw, port) {\n const headers = { ...raw }\n const connectionTokens = String(raw.connection || '')\n .split(',')\n .map((token) => token.trim().toLowerCase())\n for (const name of [...HOP_BY_HOP, ...connectionTokens, 'x-orca-share']) {\n delete headers[name]\n }\n // Dev servers (Vite, Next) allow localhost hosts by default; the public host rides x-forwarded-host.\n headers.host = `localhost:${port}`\n return headers\n}\n\nfunction refuse(res) {\n res.writeHead(404, { 'content-type': 'text/plain', 'cache-control': 'no-store' })\n res.end('not found')\n}\n\n/** Ends `close` at the grant's deadline; the timer goes away with the connection. */\nfunction deadline(untilMs, close, ...emitters) {\n const timer = setTimeout(close, Math.max(0, untilMs - Date.now()))\n for (const emitter of emitters) {\n emitter.once('close', () => clearTimeout(timer))\n }\n}\n\nconst server = http.createServer((req, res) => {\n const grant = verify(req.headers['x-orca-share'], Date.now())\n if (grant === null) {\n return refuse(res)\n }\n const { port } = grant\n const upstream = http.request(\n { host: '127.0.0.1', port, method: req.method, path: req.url, headers: upstreamHeaders(req.headers, port) },\n (answer) => {\n const headers = { ...answer.headers }\n for (const name of HOP_BY_HOP) {\n delete headers[name]\n }\n // Marks the answer as the app's, so the gateway can tell it from a route with no proxy behind it.\n headers['x-orca-share-proxy'] = '1'\n res.writeHead(answer.statusCode || 502, answer.statusMessage, headers)\n answer.pipe(res)\n }\n )\n deadline(grant.untilMs, () => {\n upstream.destroy()\n res.destroy()\n }, res)\n upstream.on('error', (error) => {\n if (res.headersSent) {\n res.destroy()\n return\n }\n // The gateway renders its own page for this; the code tells it why. Status 200 on purpose: a 5xx\n // from the VM reaches a Worker as Vercel's own 502 with our headers gone (found live).\n res.writeHead(200, { 'content-type': 'text/plain', 'x-orca-share-proxy': '1', 'x-orca-share-error': error.code === 'ECONNREFUSED' ? 'no_listener' : 'upstream_failed' })\n res.end('upstream unavailable')\n })\n req.on('aborted', () => upstream.destroy())\n req.pipe(upstream)\n})\n\nserver.on('upgrade', (req, socket, head) => {\n const grant = verify(req.headers['x-orca-share'], Date.now())\n if (grant === null) {\n socket.end('HTTP/1.1 404 Not Found\\r\\nconnection: close\\r\\ncontent-length: 0\\r\\n\\r\\n')\n return\n }\n const { port } = grant\n const headers = upstreamHeaders(req.headers, port)\n const target = net.connect(port, '127.0.0.1', () => {\n const lines = [`${req.method} ${req.url} HTTP/1.1`, `connection: upgrade`, `upgrade: ${req.headers.upgrade || 'websocket'}`]\n for (const [name, value] of Object.entries(headers)) {\n for (const item of Array.isArray(value) ? value : [value]) {\n lines.push(`${name}: ${item}`)\n }\n }\n target.write(`${lines.join('\\r\\n')}\\r\\n\\r\\n`)\n if (head && head.length > 0) {\n target.write(head)\n }\n socket.pipe(target)\n target.pipe(socket)\n })\n const close = () => {\n socket.destroy()\n target.destroy()\n }\n deadline(grant.untilMs, close, socket)\n target.on('error', () => {\n if (socket.writable) {\n socket.end('HTTP/1.1 200 OK\\r\\nx-orca-share-proxy: 1\\r\\nx-orca-share-error: no_listener\\r\\nconnection: close\\r\\ncontent-length: 0\\r\\n\\r\\n')\n }\n close()\n })\n socket.on('error', close)\n target.on('close', () => socket.destroy())\n socket.on('close', () => target.destroy())\n})\n\nserver.keepAliveTimeout = 65_000\nserver.headersTimeout = 70_000\n// No request timeout: previews can stream (SSE, long polls) until the grant's deadline.\nserver.requestTimeout = 0\nserver.listen(LISTEN_PORT, '0.0.0.0', () => {\n console.log(`orca-share-proxy listening on ${LISTEN_PORT}`)\n})\n","orca-sshd":"#!/usr/bin/env bash\n# Starts this boot's unprivileged sshd on 127.0.0.1:2222 (idempotent). Nothing outside the VM can\n# reach that port: the desktop tunnels to it over orcad's runtime connection (`orca ssh-proxy`).\n# Key-only, single user (the sandbox user), no root. Its host key and authorized_keys live under\n# ~/.orca-sandbox/ssh on the persistent disk, so the host key stays the same across stop/resume;\n# orca-image-wipe removes that directory, so every VM cloned from the golden image makes its own.\n# Prints {\"port\":2222,\"user\":\"\",\"hostKey\":\"ssh-ed25519 AAAA...\"} on success.\nset -euo pipefail\numask 077\nOPENSSH=/opt/orca/openssh\nSSH_DIR=\"$HOME/.orca-sandbox/ssh\"\nPORT=2222\nmkdir -p \"$SSH_DIR\"\nchmod 0700 \"$HOME/.orca-sandbox\" \"$SSH_DIR\"\nexec 8>\"$SSH_DIR/sshd.lock\"\nflock -w 30 8\n\nif [ ! -x \"$OPENSSH/sshd\" ]; then\n echo 'sshd is not installed in this image' >&2\n exit 3\nfi\nif [ ! -s \"$SSH_DIR/ssh_host_ed25519_key\" ]; then\n rm -f \"$SSH_DIR/ssh_host_ed25519_key\" \"$SSH_DIR/ssh_host_ed25519_key.pub\"\n ssh-keygen -q -t ed25519 -N '' -C \"orca-cloud-host\" -f \"$SSH_DIR/ssh_host_ed25519_key\"\nfi\ntouch \"$SSH_DIR/authorized_keys\"\nchmod 0600 \"$SSH_DIR/authorized_keys\"\n\n# Rewritten every start so an image update's settings apply to existing workspaces. PAM stays at\n# its compiled-in default (off): an unprivileged sshd cannot use it, and this build warns on `no`.\ncat >\"$SSH_DIR/sshd_config\" </dev/null || echo 0)\"\n# Resume reboots from disk, so a recorded pid can name a dead process or an unrelated one.\nif ! { kill -0 \"$pid\" 2>/dev/null && grep -q sshd \"/proc/$pid/cmdline\" 2>/dev/null; }; then\n rm -f \"$SSH_DIR/sshd.pid\"\n : >\"$SSH_DIR/sshd.log\"\n \"$OPENSSH/sshd\" -t -f \"$SSH_DIR/sshd_config\"\n \"$OPENSSH/sshd\" -f \"$SSH_DIR/sshd_config\" -E \"$SSH_DIR/sshd.log\"\n for _ in $(seq 1 100); do\n [ -s \"$SSH_DIR/sshd.pid\" ] && break\n sleep 0.02\n done\n [ -s \"$SSH_DIR/sshd.pid\" ] || { echo 'sshd did not start' >&2; tail -n 20 \"$SSH_DIR/sshd.log\" >&2; exit 1; }\nfi\n\nhost_key=\"$(cut -d' ' -f1-2 \"$SSH_DIR/ssh_host_ed25519_key.pub\")\"\nprintf '{\"port\":%s,\"user\":\"%s\",\"hostKey\":\"%s\"}\\n' \"$PORT\" \"$(id -un)\" \"$host_key\"\n","orca-ssh-keys":"#!/usr/bin/env bash\n# `orca-ssh-keys add|remove`: adds or removes one desktop's key in the Orca-managed authorized_keys\n# of this VM's sshd, then makes sure sshd runs. The control plane passes the key in\n# ORCA_SSH_PUBLIC_KEY (`ssh-ed25519 `), never on the command line. Keys are\n# matched by their base64 blob, so a renamed comment cannot keep a revoked key alive.\n# Prints orca-sshd's {\"port\":...,\"user\":...,\"hostKey\":...} line on success.\nset -euo pipefail\numask 077\nSSH_DIR=\"$HOME/.orca-sandbox/ssh\"\naction=\"${1:-}\"\nkey=\"${ORCA_SSH_PUBLIC_KEY:-}\"\n# grep matches per line: a second line could carry key options past the check below.\ncase \"$key\" in *$'\\n'* | *$'\\r'*) echo 'invalid public key' >&2; exit 2 ;; esac\n# One line, ed25519 only, a plain comment: nothing that sshd would read as key options.\nif ! printf '%s' \"$key\" | grep -Eq '^ssh-ed25519 [A-Za-z0-9+/]{68} [A-Za-z0-9@._:+-]{1,200}$'; then\n echo 'invalid public key' >&2\n exit 2\nfi\nblob=\"$(printf '%s' \"$key\" | cut -d' ' -f2)\"\nmkdir -p \"$SSH_DIR\"\nchmod 0700 \"$HOME/.orca-sandbox\" \"$SSH_DIR\"\nexec 7>\"$SSH_DIR/keys.lock\"\nflock -w 30 7\ntouch \"$SSH_DIR/authorized_keys\"\nnext=\"$(mktemp \"$SSH_DIR/authorized_keys.XXXXXX\")\"\n# Drop the key wherever it appears (with or without options), then append it on add.\nawk -v blob=\"$blob\" '{ for (i = 1; i <= NF; i++) if ($i == blob) next; print }' \\\n \"$SSH_DIR/authorized_keys\" >\"$next\"\ncase \"$action\" in\n add) printf '%s\\n' \"$key\" >>\"$next\" ;;\n remove) ;;\n *) rm -f \"$next\"; echo 'usage: orca-ssh-keys add|remove' >&2; exit 2 ;;\nesac\nchmod 0600 \"$next\"\nmv -f \"$next\" \"$SSH_DIR/authorized_keys\"\nexec /opt/orca/bin/orca-sshd\n","orca-desktop-start":"#!/usr/bin/env bash\n# Starts the on-demand remote desktop (idempotent) and mints one connection ticket. Prints one line:\n# {\"schemaVersion\":2,\"port\":6080,\"display\":\":1\",\"path\":\"vnc.html\",\"ticket\":\"<43 chars>\",\"expiresInMs\":60000}\n# Xvnc (X server + VNC in one) listens on a 0600 unix socket only, with no VNC auth: only this uid\n# can open it. orca-desktop-proxy (websockify + a ticket gate) serves noVNC on 127.0.0.1 and\n# bridges WebSockets to that socket. Nothing is reachable from outside the VM: the desktop app\n# reaches it through Orca's port forward, a localhost port on the user's computer that any local\n# process or web page can reach, so each WebSocket needs a ticket from here: 32 random bytes,\n# single use, valid for 60 s, stored only as its sha256 (the file name; its content is the expiry).\n# The ticket goes to stdout only (the control plane hands it to the desktop app). Never started at boot.\nset -euo pipefail\numask 077\nDESKTOP=/opt/orca/desktop\nSTATE=\"$HOME/.orca-desktop\"\nPORT=\"${ORCA_DESKTOP_PORT:-6080}\"\nDISPLAY_NUM=\"${ORCA_DESKTOP_DISPLAY:-1}\"\nGEOMETRY=\"${ORCA_DESKTOP_GEOMETRY:-1280x800}\"\nSOCKET=\"$STATE/vnc.sock\"\n# The parent's DISPLAY must not leak into the WM/xterm below; they use ours.\nexport DISPLAY=\":$DISPLAY_NUM\"\n\n# Exit 3 = this image has no desktop (built before it, or its optional install failed).\nfail() { printf 'orca-desktop: %s\\n' \"$1\" >&2; exit \"${2:-1}\"; }\ncase \"$PORT\" in '' | *[!0-9]*) fail 'ORCA_DESKTOP_PORT must be a number' ;; esac\ncase \"$DISPLAY_NUM\" in '' | *[!0-9]*) fail 'ORCA_DESKTOP_DISPLAY must be a number' ;; esac\ncase \"$GEOMETRY\" in [0-9]*x[0-9]*) ;; *) fail 'ORCA_DESKTOP_GEOMETRY must look like 1280x800' ;; esac\ncommand -v Xvnc >/dev/null || fail 'not installed in this image (Xvnc missing)' 3\n[ -s \"$DESKTOP/novnc/vnc.html\" ] || fail 'not installed in this image (noVNC missing)' 3\nPROXY=\"$(dirname \"$(readlink -f \"$0\")\")/orca-desktop-proxy\"\n[ -x \"$PROXY\" ] || fail 'orca-desktop-proxy missing next to this script'\nTICKETS=\"$STATE/tickets\"\nTICKET_TTL_S=60\n# Xvnc's mode: a previous version of this script ran it with VncAuth; restart it in this mode.\nMODE=ticket-v1\n\nmkdir -p \"$STATE\"\nexec 9>\"$STATE/start.lock\"\nflock -w 30 9 || fail 'another start is in progress'\n\npid_of() { # never \"0\": kill 0 targets our own process group\n local pid\n pid=\"$(cat \"$STATE/$1.pid\" 2>/dev/null || true)\"\n case \"$pid\" in '' | 0 | *[!0-9]*) return 1 ;; esac\n printf '%s' \"$pid\"\n}\nalive() { local pid; pid=\"$(pid_of \"$1\")\" && kill -0 \"$pid\" 2>/dev/null; }\nmint_ticket() { # prints the ticket; stores only its sha256, with the expiry as content\n local ticket now digest\n mkdir -p \"$TICKETS\"\n now=\"$(date +%s)\"\n # Expired or spent-but-unswept tickets; keep at most 16 live ones (oldest go first).\n for file in \"$TICKETS\"/*; do\n [ -f \"$file\" ] || continue\n [ \"$(cat \"$file\" 2>/dev/null || echo 0)\" -ge \"$now\" ] 2>/dev/null || rm -f \"$file\"\n done\n # shellcheck disable=SC2012 # names are hex digests\n ls -1t \"$TICKETS\" 2>/dev/null | tail -n +16 | while read -r old; do rm -f \"$TICKETS/$old\"; done\n ticket=\"$(head -c 32 /dev/urandom | base64 | tr '+/' '-_' | tr -d '=\\n')\"\n [ \"${#ticket}\" = 43 ] || fail 'could not generate a ticket'\n digest=\"$(printf '%s' \"$ticket\" | sha256sum | cut -d' ' -f1)\"\n printf '%s' \"$((now + TICKET_TTL_S))\" >\"$TICKETS/.$digest\" && mv \"$TICKETS/.$digest\" \"$TICKETS/$digest\"\n printf '%s' \"$ticket\"\n}\nready_line() {\n local ticket\n ticket=\"$(mint_ticket)\" || exit 1\n printf '{\"schemaVersion\":2,\"port\":%s,\"display\":\":%s\",\"path\":\"vnc.html\",\"ticket\":\"%s\",\"expiresInMs\":%s}\\n' \\\n \"$PORT\" \"$DISPLAY_NUM\" \"$ticket\" \"$((TICKET_TTL_S * 1000))\"\n}\nlistening() { # the proxy answers HTTP on loopback\n curl -fsS -o /dev/null --max-time 1 \"http://127.0.0.1:$PORT/vnc.html\" 2>/dev/null\n}\n\n# Pids from a previous boot (resume = reboot from disk) name dead or unrelated processes.\nboot_id=\"$(cat /proc/sys/kernel/random/boot_id)\"\nif [ \"$(cat \"$STATE/boot-id\" 2>/dev/null || true)\" != \"$boot_id\" ]; then\n rm -rf \"$STATE\"/*.pid \"$SOCKET\" \"$STATE/password\" \"$STATE/passwd\" \"$STATE/mode\" \"$TICKETS\"\n printf '%s' \"$boot_id\" >\"$STATE/boot-id\"\nfi\n\n# Same boot, older script: its websockify had no ticket gate and its Xvnc wanted a VNC password.\nrm -f \"$STATE/password\" \"$STATE/passwd\"\nif alive websockify; then kill \"$(pid_of websockify)\" 2>/dev/null || true; fi\nrm -f \"$STATE/websockify.pid\"\ncurrent_mode() { cat \"$STATE/mode\" 2>/dev/null || true; }\n\nif alive xvnc && alive proxy && listening && [ \"$(current_mode)\" = \"$MODE\" ]; then\n ready_line\n exit 0\nfi\n\nstart() { # name cmd... — detached, logs in $STATE/.log\n local name=$1; shift\n # 9>&-: children must not inherit the start lock, or the next call waits for them to exit.\n setsid nohup \"$@\" >\"$STATE/$name.log\" 2>&1 &- &\n echo $! >\"$STATE/$name.pid\"\n}\n\nif ! alive xvnc || [ \"$(current_mode)\" != \"$MODE\" ]; then\n if alive xvnc; then kill \"$(pid_of xvnc)\" 2>/dev/null || true; sleep 0.2; fi\n rm -f \"$SOCKET\"\n # -rfbport -1: no TCP VNC port at all, only a 0600 unix socket (in the 0700 state dir) for the\n # proxy. SecurityTypes None is safe only because of that: the ticket gate is in the proxy.\n # SendPrimary=0: only explicit copies (xterm copies its selection, below) leave the sandbox.\n # The X display itself takes a cookie from ~/.Xauthority (Xlib's default for this user), so only\n # this uid's processes (agents, apps they start on DISPLAY=:1) can open it.\n auth=()\n if command -v xauth >/dev/null && command -v mcookie >/dev/null; then\n xauth -q -f \"$HOME/.Xauthority\" add \":$DISPLAY_NUM\" . \"$(mcookie)\" 9>&- && auth=(-auth \"$HOME/.Xauthority\")\n fi\n start xvnc Xvnc \":$DISPLAY_NUM\" \"${auth[@]}\" -geometry \"$GEOMETRY\" -depth 24 -nolisten tcp \\\n -rfbport -1 -rfbunixpath \"$SOCKET\" -rfbunixmode 0600 \\\n -SecurityTypes None -SendPrimary=0 \\\n -AlwaysShared -AcceptSetDesktopSize -desktop 'Remote desktop'\n printf '%s' \"$MODE\" >\"$STATE/mode\"\n for _ in $(seq 1 100); do\n [ -S \"$SOCKET\" ] && break\n alive xvnc || { tail -n 20 \"$STATE/xvnc.log\" >&2; fail 'Xvnc exited'; }\n sleep 0.05\n done\n [ -S \"$SOCKET\" ] || fail 'Xvnc did not create its socket'\n if command -v xsetroot >/dev/null; then xsetroot -solid '#1e1f22' 9>&- || true; fi\n if command -v openbox >/dev/null; then\n # Dark, flat theme to match Orca; the first terminal stays maximized as the tab resizes the screen.\n printf '%s\\n' '' \\\n 'Onyx' \\\n 'yes' \\\n '' >\"$STATE/openbox.xml\"\n start wm openbox --config-file \"$STATE/openbox.xml\"\n # Let it manage the screen before the terminal maps, so its maximize rule applies.\n sleep 0.2\n elif command -v twm >/dev/null; then\n start wm twm\n fi\n if command -v xterm >/dev/null; then\n # selectToClipboard: a selection is a copy (to CLIPBOARD, which reaches this computer).\n start xterm xterm -maximized -bg '#1e1f22' -fg '#d4d4d4' -fa 'Liberation Mono,Monospace' -fs 11 \\\n -xrm 'XTerm*selectToClipboard: true'\n fi\nfi\n\nif ! alive proxy || ! listening; then\n if alive proxy; then kill \"$(pid_of proxy)\" 2>/dev/null || true; sleep 0.1; fi\n mkdir -p \"$TICKETS\"\n PYTHONPATH=\"$DESKTOP/websockify\" start proxy python3 -P -W ignore::UserWarning \"$PROXY\" \\\n --listen \"$PORT\" --web \"$DESKTOP/novnc\" --unix-target \"$SOCKET\" --tickets \"$TICKETS\"\n for _ in $(seq 1 100); do\n listening && break\n alive proxy || { tail -n 20 \"$STATE/proxy.log\" >&2; fail 'orca-desktop-proxy exited'; }\n sleep 0.05\n done\n listening || fail \"orca-desktop-proxy is not answering on 127.0.0.1:$PORT\"\nfi\nready_line\n","orca-desktop-proxy":"#!/usr/bin/env python3\n# Remote desktop gateway, started by orca-desktop-start: serves noVNC on 127.0.0.1 and bridges one\n# WebSocket per single-use ticket to Xvnc's 0600 unix socket (Xvnc itself has no VNC auth: only this\n# uid can open the socket). The port is reached only through Orca's localhost forward on the user's\n# computer, where any local process or web page could knock, so every WebSocket must carry an\n# unused, unexpired ticket minted by orca-desktop-start (see consume_ticket), from a page on the same\n# localhost origin. Tickets never reach a log: paths are scrubbed before websockify logs them.\n# orca-desktop-proxy --listen PORT --web DIR --unix-target SOCKET --tickets DIR\n# stdlib + websockify (pinned tarball in /opt/orca/desktop/websockify, on PYTHONPATH) only.\nimport argparse\nimport hashlib\nimport hmac\nimport logging\nimport os\nimport re\nimport sys\nimport time\nfrom urllib.parse import parse_qs, urlsplit\n\nfrom websockify import websocketproxy\n\nTICKET_RE = re.compile(r'^[A-Za-z0-9_-]{43}$') # 32 random bytes, base64url without padding\nSCRUB_RE = re.compile(r'([?&]ticket=)[^&\\s\\'\"]*')\nLOOPBACK_HOST_RE = re.compile(r'^(localhost|127\\.0\\.0\\.1|\\[::1\\])(:[0-9]{1,5})?$')\nWS_PATH = '/websockify'\nPAGE_SCRIPT = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'orca-desktop-page.js')\n# The page may only talk to its own origin (its WebSocket included): even a URL that tries to point\n# noVNC elsewhere cannot carry a ticket or the user's keys off this forward.\nPAGE_CSP = \"connect-src 'self'; object-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'self'\"\nPAGE_TAG = b'\\n'\n\n\ndef scrub(text):\n return SCRUB_RE.sub(r'\\1', str(text))\n\n\ndef ticket_digest(ticket):\n return hashlib.sha256(ticket.encode('ascii')).hexdigest()\n\n\ndef consume_ticket(directory, ticket, now=None):\n \"\"\"True once per minted ticket, within its lifetime. The ticket file (named by the ticket's\n sha256, holding its expiry) is unlinked on first use, so a replay or a racing second\n connection finds nothing; each request runs in its own forked process, so state is on disk.\"\"\"\n if not isinstance(ticket, str) or not TICKET_RE.match(ticket):\n return False\n digest = ticket_digest(ticket)\n match = None\n try:\n names = os.listdir(directory)\n except OSError:\n return False\n for name in names:\n # Compare every entry in constant time; never short-circuit on a prefix.\n if hmac.compare_digest(name.encode('ascii', 'replace'), digest.encode('ascii')):\n match = name\n if match is None:\n return False\n path = os.path.join(directory, match)\n try:\n with open(path, 'r', encoding='ascii') as handle:\n expires_at = int(handle.read().strip() or '0')\n except (OSError, ValueError):\n expires_at = 0\n try:\n os.unlink(path) # the consume: only one caller can win this\n except FileNotFoundError:\n return False\n return (now if now is not None else time.time()) <= expires_at\n\n\ndef same_loopback_origin(headers):\n \"\"\"The page and the WebSocket share one localhost origin (blocks other local sites and DNS\n rebinding). The port is the user's local forward, which may differ from ours, so compare the\n Origin with the Host the browser dialed rather than with a fixed port.\"\"\"\n host = (headers.get('Host') or '').strip().lower()\n origin = (headers.get('Origin') or '').strip().lower()\n return loopback_host(host) and origin == 'http://' + host\n\n\ndef loopback_host(host):\n return bool(LOOPBACK_HOST_RE.match(host or ''))\n\n\nclass TicketedProxyHandler(websocketproxy.ProxyRequestHandler):\n \"\"\"websockify's proxy handler plus the ticket + origin gate. Module level (not a closure) so\n websockify's per-connection multiprocessing can pickle it under any start method.\"\"\"\n\n def log_message(self, format, *args): # noqa: A002 (websockify's signature)\n super().log_message('%s', scrub(format % args if args else format))\n\n def reject(self, code, reason):\n self.send_response(code)\n self.send_header('Content-Length', '0')\n self.send_header('Connection', 'close')\n self.end_headers()\n self.close_connection = True\n raise self.server.EClose('desktop: websocket refused (%s)' % reason)\n\n def validate_connection(self):\n parts = urlsplit(self.path)\n ticket = (parse_qs(parts.query).get('ticket') or [''])[0]\n # Drop it before anything below (websockify's own logging included) can see self.path.\n self.path = parts.path\n if parts.path != WS_PATH:\n self.reject(404, 'path')\n if not same_loopback_origin(self.headers):\n self.reject(403, 'origin')\n if not consume_ticket(self.server.orca_tickets_dir, ticket):\n self.reject(403, 'ticket')\n\n def loopback_request(self):\n if loopback_host((self.headers.get('Host') or '').strip().lower()):\n return True\n self.send_error(403)\n return False\n\n def do_GET(self):\n if not self.loopback_request():\n return None\n path = urlsplit(self.path).path\n if path == '/orca-desktop-page.js':\n return self.send_bytes(read_file(PAGE_SCRIPT), 'text/javascript; charset=utf-8')\n if path == '/vnc.html':\n page = read_file(os.path.join(self.server.web, 'vnc.html'))\n return self.send_bytes(page.replace(b'', PAGE_TAG, 1), 'text/html; charset=utf-8', PAGE_CSP)\n return super().do_GET()\n\n def do_HEAD(self):\n if not self.loopback_request():\n return None\n return super().do_HEAD()\n\n def send_bytes(self, body, content_type, csp=None):\n self.send_response(200)\n self.send_header('Content-Type', content_type)\n if csp:\n self.send_header('Content-Security-Policy', csp)\n self.send_header('Content-Length', str(len(body)))\n self.send_header('Cache-Control', 'no-store')\n self.send_header('Referrer-Policy', 'no-referrer')\n self.end_headers()\n self.wfile.write(body)\n return None\n\n\ndef read_file(path):\n with open(path, 'rb') as handle:\n return handle.read()\n\n\ndef main(argv):\n parser = argparse.ArgumentParser()\n parser.add_argument('--listen', type=int, required=True)\n parser.add_argument('--web', required=True)\n parser.add_argument('--unix-target', required=True)\n parser.add_argument('--tickets', required=True)\n args = parser.parse_args(argv)\n logging.basicConfig(level=logging.INFO, format='%(message)s')\n server = websocketproxy.WebSocketProxy(\n RequestHandlerClass=TicketedProxyHandler,\n listen_host='127.0.0.1',\n listen_port=args.listen,\n web=args.web,\n file_only=True,\n unix_target=args.unix_target,\n )\n server.orca_tickets_dir = os.path.abspath(args.tickets)\n server.start_server()\n\n\nif __name__ == '__main__':\n main(sys.argv[1:])\n","orca-desktop-page.js":"// Orca's glue for noVNC, injected into vnc.html by orca-desktop-proxy. Orca (the desktop app's\n// main process) drives it through window.orcaDesktop:\n// - tickets: the page never connects by itself. Each WebSocket needs a fresh single-use ticket,\n// which Orca hands over with connect(ticket) after nextTicketRequest() resolves: 'ticket' on\n// load or after a session dropped, 'retry' after an attempt that never connected. Tickets live\n// only in memory here: never in the URL, storage or noVNC's settings.\n// - pause(message, label): Orca stopped retrying; show why, with a Reconnect button. resume()\n// (Orca reopened the desktop) or the button asks for a ticket again.\n// - fit: resize=remote makes Xvnc follow the tab; a server without SetDesktopSize gets scaling.\n// - clipboard: a copy inside the desktop right after user input there goes to this computer's\n// clipboard; paste(text, chord) sets the sandbox's clipboard first, then replays the paste key.\nimport UI from './app/ui.js';\nimport * as WebUtil from './app/webutil.js';\n\nconst WS_PATH = 'websockify';\nconst RESIZE_FALLBACK_MS = 1500;\n// A copy inside the desktop follows a copy key or a selection (drag or double-click) there; other\n// clipboard changes (an agent in the sandbox running xclip) must not overwrite this computer's\n// clipboard. Plain typing does not open the window.\nconst USER_COPY_WINDOW_MS = 1500;\nconst DRAG_PX = 4;\nconst MAX_CLIPBOARD_CHARS = 1 << 20;\nconst TICKET_RE = /^[A-Za-z0-9_-]{43}$/;\nconst XK = { v: 0x0076, V: 0x0056, Insert: 0xff63, Shift_L: 0xffe1, Super_L: 0xffeb, Super_R: 0xffec };\n\nlet state = 'idle'; // idle | connecting | connected | disconnected | paused\nlet attemptConnected = true;\nlet ticketWaiters = [];\nlet lastCopyIntent = 0;\nlet pointerStart = null;\n\nconst style = document.createElement('style');\n// Orca owns connecting and the chrome: noVNC's Connect button would only try without a ticket,\n// and its control bar duplicates what the Orca tab does (fit, clipboard, keyboard release).\n// The pause card follows Orca's theme: Orca sets Electron's theme source from its own setting, so\n// prefers-color-scheme here is Orca's light or dark, and it follows a switch while paused. The\n// page cannot read Orca's tokens, so these mirror them (popover, border, focus ring).\nstyle.textContent = `\n#noVNC_connect_dlg, #noVNC_control_bar_anchor { display: none !important; }\n#orca_pause { --orca-scrim: rgb(10 10 10 / 0.88); --orca-card: #171717; --orca-text: #f0f0f0;\n --orca-border: rgb(255 255 255 / 0.1); --orca-control: rgb(255 255 255 / 0.25);\n --orca-control-hover: rgb(255 255 255 / 0.08); --orca-focus: color-mix(in oklab, #f0f0f0 65%, #0a0a0a);\n color-scheme: dark; position: fixed; inset: 0; display: none; align-items: center;\n justify-content: center; padding: 16px; background: var(--orca-scrim); z-index: 1000;\n font: 13px/1.5 system-ui, sans-serif; }\n@media (prefers-color-scheme: light) {\n #orca_pause { --orca-scrim: rgb(255 255 255 / 0.88); --orca-card: #fff; --orca-text: #0a0a0a;\n --orca-border: #e5e5e5; --orca-control: #a3a3a3; --orca-control-hover: #f5f5f5;\n --orca-focus: color-mix(in oklab, #0a0a0a 55%, #fff); color-scheme: light; }\n}\n#orca_pause.open { display: flex; }\n#orca_pause > div { max-width: 360px; padding: 16px; border: 1px solid var(--orca-border);\n border-radius: 8px; background: var(--orca-card); color: var(--orca-text); text-align: center;\n box-shadow: 0 8px 24px rgb(0 0 0 / 0.16); }\n#orca_pause p { margin: 0; }\n#orca_pause button { margin-top: 12px; padding: 4px 12px; border: 1px solid var(--orca-control);\n border-radius: 6px; background: transparent; color: var(--orca-text); font: inherit; cursor: pointer; }\n#orca_pause button:hover { background: var(--orca-control-hover); }\n#orca_pause button:focus-visible { outline: 2px solid var(--orca-focus); outline-offset: 2px; }\n@media (prefers-reduced-motion: no-preference) {\n #orca_pause.open > div { animation: orca-pause-in 120ms ease-out; }\n}\n@keyframes orca-pause-in { from { opacity: 0; transform: translateY(4px); } }\n`;\ndocument.head.appendChild(style);\n\nconst overlay = document.createElement('div');\noverlay.id = 'orca_pause';\noverlay.innerHTML = '

';\noverlay.querySelector('button').addEventListener('click', () => resume());\ndocument.addEventListener('DOMContentLoaded', () => document.body.appendChild(overlay));\n\nwindow.addEventListener('keydown', (event) => {\n if ((event.ctrlKey || event.metaKey) && !event.altKey && (event.key === 'c' || event.key === 'C' || event.key === 'Insert')) {\n lastCopyIntent = Date.now();\n }\n}, true);\nwindow.addEventListener('pointerdown', (event) => {\n pointerStart = { x: event.clientX, y: event.clientY };\n}, true);\n// A double- or triple-click selects a word or line (pointer events carry no click count).\nwindow.addEventListener('mousedown', (event) => {\n if (event.detail >= 2) {\n lastCopyIntent = Date.now();\n }\n}, true);\nwindow.addEventListener('pointerup', (event) => {\n if (pointerStart && Math.hypot(event.clientX - pointerStart.x, event.clientY - pointerStart.y) >= DRAG_PX) {\n lastCopyIntent = Date.now();\n }\n pointerStart = null;\n}, true);\n\nfunction requestTicket() {\n const answer = attemptConnected ? 'ticket' : 'retry';\n const waiters = ticketWaiters;\n ticketWaiters = [];\n waiters.forEach((resolve) => resolve(answer));\n}\n\nasync function whenStarted() {\n while (document.documentElement.classList.contains('noVNC_loading')) {\n await new Promise((resolve) => setTimeout(resolve, 25));\n }\n}\n\nfunction onConnect() {\n state = 'connected';\n attemptConnected = true;\n UI.hideStatus();\n setTimeout(() => {\n // Xvnc answers SetDesktopSize; anything that does not gets scaled into the tab instead.\n if (UI.rfb && state === 'connected' && !UI.rfb._supportsSetDesktopSize) {\n UI.rfb.scaleViewport = true;\n }\n }, RESIZE_FALLBACK_MS);\n}\n\nfunction onDisconnect() {\n if (state === 'paused') {\n return;\n }\n state = 'disconnected';\n // The ticket is spent: ask Orca for a new one (a dropped forward, a restart of the desktop).\n requestTicket();\n}\n\nfunction onClipboard(event) {\n const text = event.detail && event.detail.text;\n if (typeof text !== 'string' || text.length > MAX_CLIPBOARD_CHARS) {\n return;\n }\n if (Date.now() - lastCopyIntent > USER_COPY_WINDOW_MS || !document.hasFocus()) {\n return;\n }\n navigator.clipboard.writeText(text).catch(() => {});\n}\n\nasync function connect(ticket) {\n if (typeof ticket !== 'string' || !TICKET_RE.test(ticket)) {\n return 'invalid';\n }\n if (state === 'connecting' || state === 'connected' || state === 'paused') {\n return state;\n }\n await whenStarted();\n if (UI.rfb) {\n return 'connecting';\n }\n state = 'connecting';\n attemptConnected = false;\n // UI.connect reads the path setting synchronously and opens the WebSocket in RFB's constructor;\n // the in-memory setting is restored right after, so the ticket is never kept or shown.\n // Only ever this page's own origin: noVNC also reads host, port, encrypt, repeater and logging\n // from the URL, which must never send a ticketed session (and the user's keys) elsewhere.\n WebUtil.setSetting('host', '');\n WebUtil.setSetting('port', '');\n WebUtil.setSetting('encrypt', false);\n WebUtil.setSetting('repeaterID', '');\n WebUtil.setSetting('path', `${WS_PATH}?ticket=${ticket}`);\n try {\n UI.connect();\n } finally {\n WebUtil.setSetting('path', WS_PATH);\n }\n const rfb = UI.rfb;\n if (!rfb) {\n state = 'disconnected';\n requestTicket();\n return 'failed';\n }\n rfb.addEventListener('connect', onConnect);\n rfb.addEventListener('disconnect', onDisconnect);\n rfb.addEventListener('clipboard', onClipboard);\n return 'connecting';\n}\n\n/** Pastes this computer's clipboard: the sandbox's clipboard first, then the paste key itself. */\nfunction paste(text, chord) {\n const rfb = UI.rfb;\n if (!rfb || state !== 'connected' || typeof text !== 'string' || text.length > MAX_CLIPBOARD_CHARS) {\n return false;\n }\n rfb.clipboardPasteFrom(text);\n if (chord && chord.kind === 'mac') {\n // Cmd+V: Linux apps do not paste on Super+V, so release Super and send Shift+Insert.\n rfb.sendKey(XK.Super_L, 'MetaLeft', false);\n rfb.sendKey(XK.Super_R, 'MetaRight', false);\n rfb.sendKey(XK.Shift_L, 'ShiftLeft', true);\n rfb.sendKey(XK.Insert, 'Insert');\n rfb.sendKey(XK.Shift_L, 'ShiftLeft', false);\n } else if (chord && chord.kind === 'replay') {\n // Ctrl+V, Ctrl+Shift+V, Shift+Insert: the held modifiers already reached the sandbox.\n const insert = chord.key === 'Insert';\n rfb.sendKey(insert ? XK.Insert : chord.key === 'V' ? XK.V : XK.v, insert ? 'Insert' : 'KeyV');\n }\n return true;\n}\n\nfunction pause(message, label, tone) {\n state = 'paused';\n if (UI.rfb) {\n UI.rfb.disconnect();\n }\n UI.hideStatus();\n overlay.querySelector('p').textContent = String(message || '');\n overlay.querySelector('button').textContent = String(label || 'Reconnect');\n // Asleep and starting are states, not errors: announce them politely.\n overlay.firstElementChild.setAttribute('role', tone === 'neutral' ? 'status' : 'alert');\n overlay.classList.add('open');\n overlay.querySelector('button').focus();\n return true;\n}\n\nfunction resume() {\n if (state !== 'paused') {\n return false;\n }\n overlay.classList.remove('open');\n state = 'disconnected';\n attemptConnected = true; // a person asked: start the retry budget over\n requestTicket();\n return true;\n}\n\nObject.defineProperty(window, 'orcaDesktop', {\n value: Object.freeze({\n version: 1,\n state: () => state,\n /** Resolves when the page needs a ticket: now if it is not connected, else after a drop. */\n nextTicketRequest: () => new Promise((resolve) => {\n ticketWaiters.push(resolve);\n if (state === 'idle' || state === 'disconnected') {\n requestTicket();\n }\n }),\n connect,\n paste,\n pause,\n resume\n })\n});\n","orca-sandbox-grant":"#!/usr/bin/env bash\n# Mints a fresh, single-device orcad pairing offer for one org member's device and seals it to that\n# device's X25519 key, so the control plane relays only ciphertext (the VM owner's E2EE model holds:\n# every member device gets its own revocable orcad credential, nobody else can read it).\n# Env from the control plane: ORCA_GRANT_ID, ORCA_GRANT_RECIPIENT_KEY (base64 raw X25519 public\n# key), ORCA_GRANT_KIND (desktop|mobile), ORCA_PUBLIC_WSS. Prints one JSON line:\n# {\"deviceId\":\"…\",\"sealed\":{\"v\":1,\"ephemeralPublicKeyB64\":\"…\",\"nonceB64\":\"…\",\"ciphertextB64\":\"…\"}}\n# Sealing: ECDH(ephemeral, recipient) -> HKDF-SHA256(salt = eph||recipient, info\n# \"orca-cloud-grant-v1\") -> AES-256-GCM, AAD \"orca-cloud-grant-v1:\".\nset -euo pipefail\numask 077\nORCA_HOME=/opt/orca\nSTATE=\"$HOME/.orca-sandbox\"\nDATA=\"$HOME/.orcad-data\"\nmkdir -p \"$STATE\"\nexec 9>\"$STATE/grant.lock\"\n# One mint at a time: --rotate retires unredeemed offers, so two members never share a credential.\nflock -w 30 9\n\ncase \"${ORCA_GRANT_ID:-}\" in '' | *[!A-Za-z0-9_-]*) echo 'bad grant id' >&2; exit 2 ;; esac\ncase \"${ORCA_GRANT_KIND:-}\" in desktop) scope=() ;; mobile) scope=(--mobile) ;; *) echo 'bad kind' >&2; exit 2 ;; esac\ncase \"${ORCA_GRANT_RECIPIENT_KEY:-}\" in '' | *[!A-Za-z0-9+/=]*) echo 'bad key' >&2; exit 2 ;; esac\ncase \"${ORCA_PUBLIC_WSS:-}\" in wss://*) ;; *) echo 'bad endpoint' >&2; exit 2 ;; esac\n\nnode=\"$(find \"$ORCA_HOME/runtime/runtimes\" -type f -name node | head -n 1)\"\ncli=\"$ORCA_HOME/runtime/orcad/out/cli/index.js\"\n# The workspace's project must exist on this orcad before a phone opens it: phones may not add\n# projects themselves (mobile RPC scope), and a phone may be the first client this VM ever sees.\nproject=/vercel/sandbox/project\nif [ -d \"$project\" ]; then\n kind=folder\n [ -d \"$project/.git\" ] && kind=git\n ORCA_USER_DATA_PATH=\"$DATA\" timeout 20 \"$node\" \"$cli\" repo add --path \"$project\" --kind \"$kind\" --json \\\n >/dev/null 2>&1 || true\nfi\noffer=\"$(ORCA_USER_DATA_PATH=\"$DATA\" timeout 30 \"$node\" \"$cli\" pair --json --rotate \"${scope[@]}\" \\\n --address \"$ORCA_PUBLIC_WSS\" 2>/dev/null)\" || { echo 'pair failed' >&2; exit 1; }\n# The offer goes to the sealer on stdin (never argv or disk); only the sealed form is printed.\nprintf '%s' \"$offer\" | ORCA_GRANT_ID=\"$ORCA_GRANT_ID\" ORCA_GRANT_RECIPIENT_KEY=\"$ORCA_GRANT_RECIPIENT_KEY\" \\\n \"$node\" -e '\nconst crypto = require(\"node:crypto\")\nlet input = \"\"\nprocess.stdin.on(\"data\", (c) => (input += c)).on(\"end\", () => {\n const res = JSON.parse(input).result\n if (!res || res.available !== true || !res.pairingUrl || !res.deviceId) {\n console.error(\"offer unavailable\")\n process.exit(1)\n }\n const recipient = Buffer.from(process.env.ORCA_GRANT_RECIPIENT_KEY, \"base64\")\n if (recipient.length !== 32) { console.error(\"bad key length\"); process.exit(2) }\n const recipientKey = crypto.createPublicKey({ key: { kty: \"OKP\", crv: \"X25519\", x: recipient.toString(\"base64url\") }, format: \"jwk\" })\n const eph = crypto.generateKeyPairSync(\"x25519\")\n const ephRaw = Buffer.from(eph.publicKey.export({ format: \"jwk\" }).x, \"base64url\")\n const shared = crypto.diffieHellman({ privateKey: eph.privateKey, publicKey: recipientKey })\n const key = Buffer.from(crypto.hkdfSync(\"sha256\", shared, Buffer.concat([ephRaw, recipient]), \"orca-cloud-grant-v1\", 32))\n const nonce = crypto.randomBytes(12)\n const cipher = crypto.createCipheriv(\"aes-256-gcm\", key, nonce)\n cipher.setAAD(Buffer.from(\"orca-cloud-grant-v1:\" + process.env.ORCA_GRANT_ID))\n const body = Buffer.from(JSON.stringify({ pairingUrl: res.pairingUrl, deviceId: res.deviceId, scope: res.scope }))\n const ct = Buffer.concat([cipher.update(body), cipher.final(), cipher.getAuthTag()])\n process.stdout.write(JSON.stringify({ deviceId: res.deviceId, sealed: { v: 1, ephemeralPublicKeyB64: ephRaw.toString(\"base64\"), nonceB64: nonce.toString(\"base64\"), ciphertextB64: ct.toString(\"base64\") } }) + \"\\n\")\n})'\n","orca-sandbox-revoke":"#!/usr/bin/env bash\n# Revokes member devices from orcad's device registry. orcad adopts on-disk removals at every auth\n# (an admin revoke, device-registry-store.ts), so this works whether or not orcad is running; the\n# control plane also runs it at boot, before orcad starts, for revokes queued while suspended.\n# Env: ORCA_REVOKE_DEVICE_IDS (comma list of orcad device ids). Prints {\"revoked\":,\"live\":}.\nset -euo pipefail\numask 077\nSTATE=\"$HOME/.orca-sandbox\"\nREGISTRY=\"$HOME/.orcad-data/orca-devices.json\"\nmkdir -p \"$STATE\"\nexec 9>\"$STATE/grant.lock\"\nflock -w 30 9\n\nids=\"${ORCA_REVOKE_DEVICE_IDS:-}\"\ncase \"$ids\" in '' | *[!A-Za-z0-9,_-]*) echo 'bad device ids' >&2; exit 2 ;; esac\n# Live orcad first: `orca pair --revoke` also closes the device's open sockets now. Older orcad\n# builds lack it; the on-disk removal below still blocks their next sign-in.\nORCA_HOME=/opt/orca\nnode=\"$(find \"$ORCA_HOME/runtime/runtimes\" -type f -name node 2>/dev/null | head -n 1)\"\ncli=\"$ORCA_HOME/runtime/orcad/out/cli/index.js\"\nlive=0\nif [ -n \"$node\" ] && [ -f \"$cli\" ] && [ -s \"$HOME/.orcad-data/orca-runtime.json\" ]; then\n for id in ${ids//,/ }; do\n if ORCA_USER_DATA_PATH=\"$HOME/.orcad-data\" timeout 15 \"$node\" \"$cli\" pair --revoke \"$id\" --json 2>/dev/null \\\n | jq -e '.ok == true and .result.revoked == true' >/dev/null 2>&1; then\n live=$((live + 1))\n fi\n done\nfi\nif [ ! -s \"$REGISTRY\" ]; then\n echo \"{\\\"revoked\\\":$live,\\\"live\\\":$live}\"\n exit 0\nfi\nids_json=\"$(jq -cn --arg ids \"$ids\" '$ids | split(\",\") | map(select(length > 0))')\"\nbefore=\"$(jq 'length' \"$REGISTRY\")\"\ntmp=\"$(mktemp \"$REGISTRY.revoke.XXXXXX\")\"\n# Removes the rows and any phones delegated through them (parentDeviceId), like orcad's own revoke.\njq --argjson ids \"$ids_json\" \\\n '[.[] | select((.deviceId as $d | $ids | index($d)) == null and ((.parentDeviceId // \"\") as $p | $ids | index($p)) == null)]' \\\n \"$REGISTRY\" >\"$tmp\"\nchmod 0600 \"$tmp\"\nsync \"$tmp\" 2>/dev/null || true\nmv -f \"$tmp\" \"$REGISTRY\"\nafter=\"$(jq 'length' \"$REGISTRY\")\"\necho \"{\\\"revoked\\\":$((live + before - after)),\\\"live\\\":$live}\"\n","orca-sandbox-members":"#!/usr/bin/env bash\n# Runs as root (control plane, sudo). Installs who-may-push-as-whom for `orca-git-as`:\n# /etc/orca/members/.gitconfig egress placeholder header + GitHub author identity\n# /etc/orca/members/devices.json {\"\": \"\"} (each member's paired devices)\n# Both root-only: agents never read another member's placeholder. `orca-git-identity` (root, via a\n# sudoers rule) hands an agent only the identity of the member whose device drove its turn, as orcad\n# attests it. No token lives here: the placeholder is swapped at egress, for this repository only.\n# Env: ORCA_MEMBERS_B64 = base64 JSON [{userId, name, email, authorization, deviceIds:[...]}]\n# The VM user agents run as is orcad's own user (detected). Prints {\"members\":,\"devices\":}.\nset -euo pipefail\numask 077\nDIR=/etc/orca/members\norcad_pid=\"$(pgrep -f orcad-server.js | head -n 1 || true)\"\nUSER_NAME=\"$( [ -n \"$orcad_pid\" ] && ps -o user= -p \"$orcad_pid\" | tr -d ' ' || true)\"\nUSER_NAME=\"${USER_NAME:-${ORCA_SANDBOX_USER:-${SUDO_USER:-}}}\"\ncase \"$USER_NAME\" in '' | *[!a-z0-9_-]*) echo 'bad user' >&2; exit 2 ;; esac\nmkdir -p /etc/orca\njson=\"$(printf '%s' \"${ORCA_MEMBERS_B64:-W10=}\" | base64 -d)\"\ntmp=\"$(mktemp -d /etc/orca/members.XXXXXX)\"\ncount=0\nwhile IFS= read -r row; do\n user=\"$(jq -r '.userId' <<<\"$row\")\"\n case \"$user\" in '' | *[!A-Za-z0-9_.:-]*) continue ;; esac\n file=\"$tmp/$(printf '%s' \"$user\" | tr ':' '_').gitconfig\"\n # An empty extraheader first resets the image-wide (app identity) header for this member's git.\n git config -f \"$file\" --add http.https://github.com/.extraheader ''\n git config -f \"$file\" --add http.https://github.com/.extraheader \"Authorization: $(jq -r '.authorization' <<<\"$row\")\"\n git config -f \"$file\" user.name \"$(jq -r '.name' <<<\"$row\")\"\n git config -f \"$file\" user.email \"$(jq -r '.email' <<<\"$row\")\"\n count=$((count + 1))\ndone < <(jq -c '.[]' <<<\"$json\")\njq -c '[.[] | select(.userId | test(\"^[A-Za-z0-9_.:-]+$\")) | .userId as $u | (.deviceIds // [])[] | select(test(\"^[A-Za-z0-9_-]{1,128}$\")) | {key: ., value: $u}] | from_entries' <<<\"$json\" >\"$tmp/devices.json\"\ndevices=\"$(jq 'length' \"$tmp/devices.json\")\"\nchmod 0700 \"$tmp\" && chmod 0600 \"$tmp\"/*\nrm -rf \"$DIR.old\"\n[ -d \"$DIR\" ] && mv \"$DIR\" \"$DIR.old\"\nmv \"$tmp\" \"$DIR\"\nrm -rf \"$DIR.old\"\n# Agents may ask for their own sender's identity, and only that (the helper checks with orcad).\nrule=\"$USER_NAME ALL=(root) NOPASSWD:SETENV: /opt/orca/bin/orca-git-identity\"\nprintf '%s\\n' \"$rule\" >/etc/sudoers.d/orca-git-identity.new\nchmod 0440 /etc/sudoers.d/orca-git-identity.new\nif visudo -cf /etc/sudoers.d/orca-git-identity.new >/dev/null; then\n mv -f /etc/sudoers.d/orca-git-identity.new /etc/sudoers.d/orca-git-identity\nelse\n rm -f /etc/sudoers.d/orca-git-identity.new\n echo 'sudoers rule rejected' >&2\n exit 1\nfi\n# Pre-attestation layout (agent-readable member files) must not linger.\nuser_home=\"$(getent passwd \"$USER_NAME\" | cut -d: -f6)\"\n[ -n \"$orcad_pid\" ] && user_home=\"$(tr '\\0' '\\n' <\"/proc/$orcad_pid/environ\" | sed -n 's/^HOME=//p' | head -n 1)\"\n[ -n \"$user_home\" ] && rm -rf \"$user_home/.orca-sandbox/members\"\n# Commits outside a teammate's turn still need an author (images older than orca-sandbox-start's default).\nif [ -n \"$user_home\" ]; then\n sudo -u \"$USER_NAME\" env HOME=\"$user_home\" git config --global user.email >/dev/null 2>&1 \\\n || sudo -u \"$USER_NAME\" env HOME=\"$user_home\" git config --global user.email 'cloud@users.noreply.onorca.dev'\n sudo -u \"$USER_NAME\" env HOME=\"$user_home\" git config --global user.name >/dev/null 2>&1 \\\n || sudo -u \"$USER_NAME\" env HOME=\"$user_home\" git config --global user.name 'Orca Cloud'\nfi\necho \"{\\\"members\\\":$count,\\\"devices\\\":$devices}\"\n","orca-sandbox-read-snapshot":"#!/usr/bin/env bash\n# Seals a read-only snapshot of this workspace (chats, agent status, git, PR) to the reader keys the\n# control plane passes, right before the drain. Only ciphertext is printed (one JSON line); see\n# orca-read-snapshot.cjs. Exit 3: orcad isn't running (nothing to read).\nset -euo pipefail\numask 077\nORCA_HOME=/opt/orca\nexport ORCA_USER_DATA_PATH=\"${ORCA_USER_DATA_PATH:-$HOME/.orcad-data}\"\nnode=\"$(find \"$ORCA_HOME/runtime/runtimes\" -type f -name node | head -n 1)\"\n[ -n \"$node\" ] || { echo 'node not found' >&2; exit 1; }\nexec timeout 35 \"$node\" \"$ORCA_HOME/bin/orca-read-snapshot.cjs\"\n","orca-read-snapshot.cjs":"#!/usr/bin/env node\n// Gathers what a sleeping workspace should still show (recent chats per agent session, agent\n// status, git status/diff summary, PR link) from the running orcad over its local socket, then seals\n// it to the reader keys the control plane passed, so only ciphertext leaves the VM.\n// Run by orca-sandbox-read-snapshot right before the drain. Env:\n// ORCA_READ_SNAPSHOT_ID rsn_<24 hex> ORCA_READ_WORKSPACE_ID sbx_<24 hex>\n// ORCA_READ_RECIPIENTS JSON [{keyId, publicKeyB64}] ORCA_READ_REASON sleep|rollover\n// ORCA_USER_DATA_PATH orcad's data dir (orca-runtime.json lives there)\n// Prints one JSON line: {v:1, snapshotId, workspaceId, nonceB64, ciphertextB64, recipients[], stats}.\n// Construction (keep in sync with src/shared/cloud-workspaces/read-snapshot.ts in the app):\n// body = AES-256-GCM(dek, nonce, JSON, AAD \"orca-cloud-read-v1::\")\n// wrapped = AES-256-GCM(HKDF-SHA256(X25519(eph, reader), eph||reader, \"orca-cloud-read-wrap-v1\"),\n// nonce_i, dek, AAD \"orca-cloud-read-wrap-v1:::\")\n'use strict'\nconst crypto = require('node:crypto')\nconst fs = require('node:fs')\nconst net = require('node:net')\nconst path = require('node:path')\n\nconst INFO = 'orca-cloud-read-v1'\nconst WRAP_INFO = 'orca-cloud-read-wrap-v1'\nconst PROJECT = '/vercel/sandbox/project'\nconst LIMITS = { sessions: 12, messagesPerSession: 60, messageChars: 4000, changes: 200, commits: 10 }\n/** Plaintext budget: sealed + base64 it stays under the control plane's 220 kB and the 256 kB stdout cap. */\nconst MAX_PLAIN_BYTES = 150_000\nconst CALL_TIMEOUT_MS = 5_000\nconst TOTAL_BUDGET_MS = 20_000\n\nfunction b64(bytes) {\n return Buffer.from(bytes).toString('base64')\n}\n\nfunction x25519PublicKey(raw) {\n return crypto.createPublicKey({ key: { kty: 'OKP', crv: 'X25519', x: Buffer.from(raw).toString('base64url') }, format: 'jwk' })\n}\n\nfunction gcmSeal(key, nonce, plain, aad) {\n const cipher = crypto.createCipheriv('aes-256-gcm', key, nonce)\n cipher.setAAD(Buffer.from(aad))\n return Buffer.concat([cipher.update(plain), cipher.final(), cipher.getAuthTag()])\n}\n\n/** Seals `payload` (an object) to every recipient; a malformed key is skipped, not fatal. */\nfunction seal(payload, recipients, workspaceId, snapshotId) {\n const scope = `${workspaceId}:${snapshotId}`\n const dek = crypto.randomBytes(32)\n const nonce = crypto.randomBytes(12)\n const ciphertext = gcmSeal(dek, nonce, Buffer.from(JSON.stringify(payload)), `${INFO}:${scope}`)\n const sealedTo = []\n for (const recipient of recipients) {\n const reader = Buffer.from(String(recipient.publicKeyB64 || ''), 'base64')\n if (reader.length !== 32 || !/^rk_[0-9a-f]{24}$/.test(String(recipient.keyId || ''))) {\n continue\n }\n let shared\n const eph = crypto.generateKeyPairSync('x25519')\n try {\n shared = crypto.diffieHellman({ privateKey: eph.privateKey, publicKey: x25519PublicKey(reader) })\n } catch {\n continue\n }\n if (shared.every((byte) => byte === 0)) {\n continue\n }\n const ephRaw = Buffer.from(eph.publicKey.export({ format: 'jwk' }).x, 'base64url')\n const kek = Buffer.from(crypto.hkdfSync('sha256', shared, Buffer.concat([ephRaw, reader]), WRAP_INFO, 32))\n const wrapNonce = crypto.randomBytes(12)\n const wrapped = gcmSeal(kek, wrapNonce, dek, `${WRAP_INFO}:${scope}:${recipient.keyId}`)\n sealedTo.push({ keyId: recipient.keyId, ephemeralPublicKeyB64: b64(ephRaw), nonceB64: b64(wrapNonce), wrappedKeyB64: b64(wrapped) })\n }\n dek.fill(0)\n return { v: 1, snapshotId, workspaceId, nonceB64: b64(nonce), ciphertextB64: b64(ciphertext), recipients: sealedTo }\n}\n\n// --- gathering -------------------------------------------------------------------------------\n\n/** One request per connection, like the CLI. A streaming method resolves on its first frame. */\nfunction rpc(metadata, method, params, timeoutMs = CALL_TIMEOUT_MS) {\n return new Promise((resolve) => {\n const transport = (metadata.transports || [metadata.transport]).find((t) => t && (t.kind === 'unix' || t.kind === 'named-pipe'))\n if (!transport) {\n resolve(null)\n return\n }\n const socket = net.createConnection(transport.endpoint)\n const id = crypto.randomUUID()\n let buffer = ''\n let done = false\n const finish = (value) => {\n if (!done) {\n done = true\n clearTimeout(timer)\n socket.destroy()\n resolve(value)\n }\n }\n const timer = setTimeout(() => finish(null), timeoutMs)\n socket.setEncoding('utf8')\n socket.on('error', () => finish(null))\n socket.on('close', () => finish(null))\n socket.on('connect', () => socket.write(`${JSON.stringify({ id, authToken: metadata.authToken, method, params })}\\n`))\n socket.on('data', (chunk) => {\n buffer += chunk\n let newline\n while ((newline = buffer.indexOf('\\n')) !== -1) {\n const line = buffer.slice(0, newline)\n buffer = buffer.slice(newline + 1)\n let frame\n try {\n frame = JSON.parse(line)\n } catch {\n continue\n }\n if (!frame || frame.id !== id) {\n continue\n }\n finish(frame.ok === true ? frame.result : null)\n return\n }\n })\n })\n}\n\nconst isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v)\nconst str = (v, max) => (typeof v === 'string' ? v.slice(0, max) : null)\nconst num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null)\n\nfunction messagesOf(history) {\n const items = isObj(history) && isObj(history.page) && Array.isArray(history.page.items) ? history.page.items : []\n const out = []\n for (const item of items) {\n const body = isObj(item) && isObj(item.body) ? item.body : null\n if (!body || body.kind !== 'message' || !Array.isArray(body.blocks)) {\n continue\n }\n const role = body.role\n if (role !== 'user' && role !== 'assistant' && role !== 'system') {\n continue\n }\n const text = body.blocks\n .filter((b) => isObj(b) && b.type === 'text' && typeof b.text === 'string')\n .map((b) => b.text)\n .join('\\n')\n .trim()\n if (text) {\n out.push({ itemId: String(item.itemId).slice(0, 200), role, text: text.slice(0, LIMITS.messageChars), at: num(item.observedAt) ?? 0 })\n }\n }\n return { messages: out, hasOlder: isObj(history) && isObj(history.page) && history.page.hasOlder === true }\n}\n\nfunction gitOf(status, log) {\n if (!isObj(status) && !isObj(log)) {\n return null\n }\n const entries = isObj(status) && Array.isArray(status.entries) ? status.entries.filter(isObj) : []\n let added = 0\n let removed = 0\n let counted = false\n const changes = entries.slice(0, LIMITS.changes).map((e) => {\n const a = num(e.added)\n const r = num(e.removed)\n if (a !== null || r !== null) {\n counted = true\n }\n return { path: String(e.path).slice(0, 1024), status: str(e.status, 20) || 'modified', area: str(e.area, 20) || 'unstaged', added: a, removed: r }\n })\n for (const e of entries) {\n added += num(e.added) || 0\n removed += num(e.removed) || 0\n }\n const items = isObj(log) && Array.isArray(log.items) ? log.items.filter(isObj) : []\n return {\n branch: isObj(status) && typeof status.branch === 'string' ? status.branch.replace(/^refs\\/heads\\//, '') : null,\n head: isObj(status) ? str(status.head, 64) : null,\n changes,\n changeCount: entries.length,\n added: counted ? added : null,\n removed: counted ? removed : null,\n commits: items.slice(0, LIMITS.commits).map((c) => ({\n id: String(c.id).slice(0, 64),\n subject: String(c.subject ?? '').slice(0, 300),\n author: str(c.author, 120),\n at: num(c.timestamp)\n }))\n }\n}\n\nfunction prOf(linked) {\n if (!isObj(linked) || num(linked.number) === null || typeof linked.url !== 'string' || !linked.url.startsWith('https://')) {\n return null\n }\n return {\n number: linked.number,\n title: String(linked.title ?? '').slice(0, 300),\n state: str(linked.state, 20) || 'open',\n url: linked.url.slice(0, 500),\n checksStatus: str(linked.checksStatus, 20),\n checksSummary: str(linked.checksSummary, 200)\n }\n}\n\nconst STATUSES = new Set(['working', 'attention', 'idle'])\nconst PANE_PREFIX = 'structured-agent-session-'\n\n/**\n * Chats as orcad stores them (agent-session-journal.db, read-only): every session's provider, name\n * and last turn, open tabs first. The local socket can't stream agentSession.subscribeStatus, and\n * worktree.ps lists only agents that are live right now, so this is the complete list.\n */\nfunction storedSessions(dataDir) {\n let db\n try {\n const { DatabaseSync } = require('node:sqlite')\n db = new DatabaseSync(path.join(dataDir, 'agent-session-journal.db'), { readOnly: true })\n const open = new Set(db.prepare('SELECT session_id FROM agent_session_tabs').all().map((r) => r.session_id))\n const out = []\n for (const row of db.prepare('SELECT session_id, record_json FROM agent_session_records').all()) {\n let record\n try {\n record = JSON.parse(row.record_json)\n } catch {\n continue\n }\n const last = isObj(record.lastTurn) ? record.lastTurn : {}\n out.push({\n sessionId: row.session_id,\n agent: str(record.provider, 40),\n title: str(record.conversationName, 200) || str(last.prompt, 200),\n status: last.state === 'running' || last.state === 'submitted' ? 'working' : last.state === 'settled' ? 'idle' : 'unknown',\n turnOutcome: str(last.outcome, 40),\n updatedAt: num(record.updatedAt),\n open: open.has(row.session_id),\n lastPrompt: str(last.prompt, LIMITS.messageChars),\n lastReply: str(last.reply, LIMITS.messageChars),\n lastAt: num(last.at)\n })\n }\n return out\n } catch {\n return []\n } finally {\n try {\n db && db.close()\n } catch {}\n }\n}\n\n/** Live agent rows from worktree.ps, keyed by session id (their status wins over the stored one). */\nfunction liveAgents(worktrees) {\n const out = new Map()\n for (const w of worktrees) {\n for (const a of Array.isArray(w.agents) ? w.agents.filter(isObj) : []) {\n const tab = typeof a.paneKey === 'string' ? a.paneKey.split(':')[0] : ''\n if (!tab.startsWith(PANE_PREFIX)) {\n continue\n }\n const state = a.mainAgent && typeof a.mainAgent.state === 'string' ? a.mainAgent.state : a.state\n out.set(tab.slice(PANE_PREFIX.length), {\n agent: str(a.agentType, 40),\n title: str(a.conversationName, 200) || str(a.taskTitle, 200) || str(a.displayName, 200),\n status: state === 'working' ? 'working' : state === 'blocked' || state === 'waiting' || state === 'attention' ? 'attention' : 'idle',\n updatedAt: num(a.updatedAt)\n })\n }\n }\n return out\n}\n\n/** `call(method, params)` -> result | null. Never throws: a missing piece is left out. */\nasync function gather(call, { workspaceId, snapshotId, reason, now, deadline, listSessions = () => [] }) {\n const timeLeft = () => deadline - Date.now()\n const ps = await call('worktree.ps', { limit: 20 })\n const worktrees = isObj(ps) && Array.isArray(ps.worktrees) ? ps.worktrees.filter(isObj) : []\n const project = worktrees.find((w) => w.path === PROJECT) || worktrees[0] || null\n const selector = project && typeof project.path === 'string' ? `path:${project.path}` : `path:${PROJECT}`\n const [status, log] = await Promise.all([\n call('git.status', { worktree: selector, includeLineStats: true }),\n call('git.history', { worktree: selector, limit: LIMITS.commits })\n ])\n const live = liveAgents(worktrees)\n const byId = new Map()\n for (const s of listSessions()) {\n byId.set(s.sessionId, s)\n }\n for (const [sessionId, a] of live) {\n byId.set(sessionId, { ...(byId.get(sessionId) || { sessionId, open: true }), ...Object.fromEntries(Object.entries(a).filter(([, v]) => v !== null)) })\n }\n // Open chats first, then newest activity.\n const picked = [...byId.values()]\n .filter((s) => typeof s.sessionId === 'string')\n .sort((a, b) => Number(Boolean(b.open)) - Number(Boolean(a.open)) || (num(b.updatedAt) || 0) - (num(a.updatedAt) || 0))\n .slice(0, LIMITS.sessions)\n const sessions = []\n for (const s of picked) {\n const history = timeLeft() > 1_000 ? await call('agentSession.history', { sessionId: s.sessionId, direction: 'tail', limit: LIMITS.messagesPerSession }) : null\n let { messages, hasOlder } = messagesOf(history)\n if (messages.length === 0) {\n // No readable history (or out of time): the stored last turn still says what happened.\n const at = s.lastAt || s.updatedAt || 0\n messages = [\n ...(s.lastPrompt ? [{ itemId: `${s.sessionId}:last-prompt`, role: 'user', text: s.lastPrompt, at }] : []),\n ...(s.lastReply ? [{ itemId: `${s.sessionId}:last-reply`, role: 'assistant', text: s.lastReply, at }] : [])\n ]\n hasOlder = hasOlder || messages.length > 0\n }\n sessions.push({\n sessionId: s.sessionId.slice(0, 200),\n agent: s.agent || null,\n title: s.title || null,\n status: STATUSES.has(s.status) ? s.status : 'unknown',\n turnOutcome: s.turnOutcome || null,\n updatedAt: num(s.updatedAt),\n messages: messages.slice(-LIMITS.messagesPerSession),\n truncated: hasOlder || messages.length > LIMITS.messagesPerSession\n })\n }\n return {\n v: 1,\n workspaceId,\n snapshotId,\n capturedAt: now,\n reason,\n git: gitOf(status, log),\n pr: prOf(project && project.linkedPR),\n sessions\n }\n}\n\n/** Cuts the oldest messages (then long texts, then sessions) until the JSON fits the budget. */\nfunction fitToBudget(payload, maxBytes = MAX_PLAIN_BYTES) {\n const size = () => Buffer.byteLength(JSON.stringify(payload))\n let guard = 0\n while (size() > maxBytes && guard++ < 10_000) {\n const longest = payload.sessions.reduce((best, s) => (!best || s.messages.length > best.messages.length ? s : best), null)\n if (longest && longest.messages.length > 4) {\n longest.messages.shift()\n longest.truncated = true\n continue\n }\n const longText = payload.sessions.flatMap((s) => s.messages).find((m) => m.text.length > 500)\n if (longText) {\n longText.text = `${longText.text.slice(0, 500)}…`\n continue\n }\n if (payload.git && payload.git.changes.length > 20) {\n payload.git.changes = payload.git.changes.slice(0, 20)\n continue\n }\n if (payload.sessions.length > 1) {\n payload.sessions.pop()\n continue\n }\n payload.sessions = []\n break\n }\n return payload\n}\n\nasync function main() {\n const started = Date.now()\n const env = process.env\n const snapshotId = env.ORCA_READ_SNAPSHOT_ID || ''\n const workspaceId = env.ORCA_READ_WORKSPACE_ID || ''\n if (!/^rsn_[0-9a-f]{24}$/.test(snapshotId) || !/^sbx_[0-9a-f]{24}$/.test(workspaceId)) {\n process.stderr.write('bad ids\\n')\n process.exit(2)\n }\n let recipients\n try {\n recipients = JSON.parse(env.ORCA_READ_RECIPIENTS || '[]')\n } catch {\n recipients = null\n }\n if (!Array.isArray(recipients) || recipients.length === 0) {\n process.stderr.write('no recipients\\n')\n process.exit(2)\n }\n const dataDir = env.ORCA_USER_DATA_PATH || path.join(env.HOME || '', '.orcad-data')\n let metadata\n try {\n metadata = JSON.parse(fs.readFileSync(path.join(dataDir, 'orca-runtime.json'), 'utf8'))\n } catch {\n metadata = null\n }\n if (!metadata || !metadata.authToken) {\n process.stderr.write('orcad not running\\n')\n process.exit(3)\n }\n const deadline = started + TOTAL_BUDGET_MS\n const call = (method, params) => rpc(metadata, method, params, Math.max(250, Math.min(CALL_TIMEOUT_MS, deadline - Date.now())))\n const payload = fitToBudget(\n await gather(call, { workspaceId, snapshotId, reason: (env.ORCA_READ_REASON || 'sleep').slice(0, 20), now: Date.now(), deadline, listSessions: () => storedSessions(dataDir) })\n )\n const out = seal(payload, recipients, workspaceId, snapshotId)\n // Timing only: counts and sizes would describe the plaintext to the control plane's logs.\n out.stats = { collectMs: Date.now() - started }\n process.stdout.write(`${JSON.stringify(out)}\\n`)\n}\n\nmodule.exports = { seal, gather, fitToBudget, messagesOf, gitOf, prOf, rpc, storedSessions, liveAgents }\n\nif (require.main === module) {\n // A fixed message: an error text could carry workspace content into the control plane's logs.\n main().catch(() => {\n process.stderr.write('read snapshot failed\\n')\n process.exit(1)\n })\n}\n","orca-git-as":"#!/usr/bin/env bash\n# Runs git as the teammate whose message started this agent's turn: their GitHub identity for\n# pushes/PRs (this repository only) and their commit author.\n# orca-git-as e.g. orca-git-as push origin HEAD\n# orca-git-as --as refuses unless that member really sent the message\n# Orca attests the sender from the paired device that sent the message, never from arguments or\n# message text. Without an attested sender (not run from an agent, or the owner's local session) it\n# runs plain git with the workspace identity.\nset -euo pipefail\nexpect=''\nif [ \"${1:-}\" = '--as' ]; then\n expect=\"${2:-}\"\n shift 2 || { echo 'usage: orca-git-as [--as ] ' >&2; exit 2; }\n case \"$expect\" in '' | *[!A-Za-z0-9_.:-]*) echo 'orca-git-as: bad member id' >&2; exit 2 ;; esac\nfi\nset +e\nfile=\"$(ORCA_GIT_AS=\"$expect\" sudo -n --preserve-env=ORCA_GIT_AS,ORCA_TERMINAL_HANDLE,ORCA_PANE_KEY,ORCA_AGENT_LAUNCH_TOKEN,ORCA_AGENT_SESSION_ID \\\n /opt/orca/bin/orca-git-identity)\"\nstatus=$?\nset -e\ncase \"$status\" in\n 0)\n trap 'rm -f \"$file\"' EXIT\n git -c \"include.path=$file\" \"$@\"\n ;;\n 3)\n echo 'orca-git-as: no teammate identity for this turn; using the workspace identity' >&2\n exec git \"$@\"\n ;;\n *) exit 4 ;;\nesac\n","orca-git-identity":"#!/usr/bin/env bash\n# Root helper behind `orca-git-as` (sudoers: the VM user may run only this). Asks orcad, as the\n# calling agent, which paired device sent the message that started the agent's latest turn\n# (`orca sender`: orcad identifies the agent from its launch evidence, never from arguments), maps\n# that device to a workspace member, and prints that member's git config file for the caller to\n# include. Optional ORCA_GIT_AS: the member the agent expects; any other answer is refused.\n# Exit codes: 0 printed a config path; 3 no member identity (use the workspace identity); 4 refused.\nset -euo pipefail\nDIR=/etc/orca/members\ncaller=\"${SUDO_USER:-}\"\ncase \"$caller\" in '' | root | *[!a-z0-9_-]*) echo 'orca-git-identity: run through orca-git-as' >&2; exit 4 ;; esac\n# orcad's own data dir and HOME (the agent's user may not use its passwd home, e.g. HOME=/vercel).\norcad_pid=\"$(pgrep -u \"$caller\" -f orcad-server.js | head -n 1 || true)\"\n[ -n \"$orcad_pid\" ] || exit 3\norcad_env() { tr '\\0' '\\n' <\"/proc/$orcad_pid/environ\" | sed -n \"s/^$1=//p\" | head -n 1; }\nhome=\"$(orcad_env HOME)\"\ndata=\"$(orcad_env ORCA_USER_DATA)\"\ndata=\"${data:-$home/.orcad-data}\"\nnode=\"$(find /opt/orca/runtime/runtimes -type f -name node | head -n 1)\"\ncli=/opt/orca/runtime/orcad/out/cli/index.js\n# Only the evidence variables orcad needs reach the query, which runs as the caller, not root.\nanswer=\"$(sudo -u \"$caller\" env -i HOME=\"$home\" PATH=/usr/bin:/bin ORCA_USER_DATA_PATH=\"$data\" \\\n ${ORCA_TERMINAL_HANDLE:+ORCA_TERMINAL_HANDLE=\"$ORCA_TERMINAL_HANDLE\"} \\\n ${ORCA_PANE_KEY:+ORCA_PANE_KEY=\"$ORCA_PANE_KEY\"} \\\n ${ORCA_AGENT_LAUNCH_TOKEN:+ORCA_AGENT_LAUNCH_TOKEN=\"$ORCA_AGENT_LAUNCH_TOKEN\"} \\\n ${ORCA_AGENT_SESSION_ID:+ORCA_AGENT_SESSION_ID=\"$ORCA_AGENT_SESSION_ID\"} \\\n timeout 15 \"$node\" \"$cli\" sender --json 2>/dev/null || true)\"\ndevice=\"$(jq -r '.result.sender.deviceId // empty' <<<\"$answer\" 2>/dev/null || true)\"\nif [ -z \"$device\" ] || [ ! -s \"$DIR/devices.json\" ]; then\n if [ -n \"${ORCA_GIT_AS:-}\" ]; then\n echo \"orca-git-as: Orca cannot confirm that $ORCA_GIT_AS sent this agent's latest message; refusing to push as them.\" >&2\n exit 4\n fi\n exit 3\nfi\nmember=\"$(jq -r --arg d \"$device\" '.[$d] // empty' \"$DIR/devices.json\")\"\nif [ -z \"$member\" ]; then\n [ -n \"${ORCA_GIT_AS:-}\" ] && { echo \"orca-git-as: the sender's device is not linked to a workspace member; refusing.\" >&2; exit 4; }\n exit 3\nfi\nif [ -n \"${ORCA_GIT_AS:-}\" ] && [ \"$ORCA_GIT_AS\" != \"$member\" ]; then\n echo \"orca-git-as: this agent's latest message came from $member, not $ORCA_GIT_AS; refusing to push as someone else.\" >&2\n exit 4\nfi\nfile=\"$DIR/$(printf '%s' \"$member\" | tr ':' '_').gitconfig\"\n[ -s \"$file\" ] || exit 3\n# The caller reads the identity through this one-shot copy (owned by them, removed by orca-git-as).\nout=\"$(sudo -u \"$caller\" mktemp)\"\ncat \"$file\" >\"$out\"\necho \"$out\"\n","orcad-boot":"#!/usr/bin/env node\n// Starts orcad from a V8 code cache taken after a full startup, so a boot skips compiling the\n// functions startup runs. NODE_COMPILE_CACHE only stores what V8 compiles before the bundle runs\n// (about 5 of its 15 MB); every other function compiled lazily on every boot (~300 ms of wake).\n// orcad-boot --code-cache [--write-code-cache] [orcad args...]\n// orcad sees the argv `node [orcad args...]`, as if started directly.\n// --write-code-cache (the image's smoke run) writes the cache when orcad exits. The cache is used\n// only when its header matches this bundle's bytes and this Node; otherwise orcad loads exactly as\n// before (plain require, which NODE_COMPILE_CACHE still serves). Plain Node, no dependencies.\n// getBuiltinModule (Node >= 22.3) works whether node loads this extensionless file as CommonJS\n// (in the VM) or as an ES module (under this repo's type:module package, in tests).\nconst fs = process.getBuiltinModule('node:fs')\nconst path = process.getBuiltinModule('node:path')\nconst vm = process.getBuiltinModule('node:vm')\nconst zlib = process.getBuiltinModule('node:zlib')\nconst { Module, createRequire } = process.getBuiltinModule('node:module')\n\nconst MAGIC = 'orcad-code-cache-v1'\n\nconst args = process.argv.slice(2)\nlet cacheFile = null\nlet writeCache = false\nwhile (args[0] === '--code-cache' || args[0] === '--write-code-cache') {\n if (args[0] === '--code-cache') {\n cacheFile = args[1]\n args.splice(0, 2)\n } else {\n writeCache = true\n args.shift()\n }\n}\nconst entry = args.shift()\nif (!entry || !cacheFile) {\n console.error('usage: orcad-boot --code-cache [--write-code-cache] [args...]')\n process.exit(2)\n}\n// As for `node `: argv[1] is the resolved path, __filename the real one.\nprocess.argv = [process.argv[0], path.resolve(entry), ...args]\nlet file = process.argv[1]\ntry {\n file = fs.realpathSync(file)\n} catch {\n // A missing bundle fails in require below, as it would under plain node.\n}\n\n// One line of identity: a cache from another bundle or Node must never run (V8 only checks length).\nfunction cacheHeader(bytes) {\n return `${MAGIC} ${process.version} ${process.arch} ${bytes.length} ${zlib.crc32(bytes)}\\n`\n}\n\nfunction readCache(header) {\n let data\n try {\n data = fs.readFileSync(cacheFile)\n } catch {\n return null\n }\n const headerLength = Buffer.byteLength(header)\n if (data.length <= headerLength || data.toString('latin1', 0, headerLength) !== header) {\n console.error('orcad-boot: code cache is for another orcad build; loading without it')\n return null\n }\n return data.subarray(headerLength)\n}\n\nfunction runCompiled(header, source, cachedData) {\n // A vm.Script can serialize what startup compiled; the CommonJS loader cannot. Same wrapper,\n // filename and require as the loader, and import() resolves from the bundle like it does there.\n const options = {\n filename: file,\n cachedData: cachedData ?? undefined,\n importModuleDynamically: vm.constants.USE_MAIN_CONTEXT_DEFAULT_LOADER\n }\n // Node flags the loader option experimental once, on the first import() through it. Spend that\n // one-time warning here, unprinted, so orcad's stderr stays as it was.\n const emitWarning = process.emitWarning\n process.emitWarning = (warning, ...rest) => {\n if (!String(warning?.message ?? warning).includes('USE_MAIN_CONTEXT_DEFAULT_LOADER')) {\n emitWarning.call(process, warning, ...rest)\n }\n }\n let script\n try {\n new vm.Script('import(\"node:path\")', {\n filename: file,\n importModuleDynamically: options.importModuleDynamically\n })\n .runInThisContext()\n .catch(() => {})\n script = new vm.Script(Module.wrap(source), options)\n } finally {\n process.emitWarning = emitWarning\n }\n if (cachedData && script.cachedDataRejected) {\n console.error('orcad-boot: V8 rejected the code cache (other V8 flags?); compiled without it')\n }\n if (writeCache) {\n process.on('exit', () => {\n try {\n const data = script.createCachedData()\n const temporary = `${cacheFile}.${process.pid}.tmp`\n fs.writeFileSync(temporary, Buffer.concat([Buffer.from(header, 'latin1'), data]))\n fs.renameSync(temporary, cacheFile)\n console.error(`orcad-boot: wrote ${data.length} bytes of code cache`)\n } catch (error) {\n console.error(`orcad-boot: could not write the code cache: ${error.message}`)\n }\n })\n }\n const module = new Module(file, null)\n module.filename = file\n module.paths = Module._nodeModulePaths(path.dirname(file))\n const compiled = script.runInThisContext()\n compiled.call(module.exports, module.exports, createRequire(file), module, file, path.dirname(file))\n}\n\n// Locals, so neither the bundle bytes nor the cache outlive the compile.\nfunction boot() {\n // Older Node (no crc32 or main-context import()) loads as before.\n if (typeof zlib.crc32 === 'function' && vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER) {\n let bytes = null\n try {\n bytes = fs.readFileSync(file)\n } catch {\n // Missing or unreadable: require reports it as plain node would.\n }\n if (bytes) {\n const header = cacheHeader(bytes)\n const cachedData = readCache(header)\n if (cachedData || writeCache) {\n runCompiled(header, bytes.toString('utf8'), cachedData)\n return\n }\n }\n }\n createRequire(file)(file)\n}\n\nboot()\n","git":"#!/usr/bin/env bash\n# git for agents in Orca Cloud workspaces (first on orcad's PATH). Commands that author or publish\n# work run as the teammate whose message started this agent's turn (orca-git-as: orcad attests the\n# sender's paired device; root-only member identities). Everything else is plain git, untouched.\nreal=/usr/bin/git\nsub=''\nskip=0\nfor arg in \"$@\"; do\n if [ \"$skip\" = 1 ]; then skip=0; continue; fi\n case \"$arg\" in\n -C | -c | --git-dir | --work-tree | --namespace | --exec-path | --config-env) skip=1 ;;\n -*) ;;\n *) sub=\"$arg\"; break ;;\n esac\ndone\ncase \"$sub\" in\n commit | push | merge | rebase | cherry-pick | revert | am | pull | tag)\n # Outside an agent turn (no attested sender) orca-git-as falls back to the workspace identity.\n if [ -n \"${ORCA_TERMINAL_HANDLE:-}${ORCA_AGENT_SESSION_ID:-}\" ] && [ -x /opt/orca/bin/orca-git-as ]; then\n PATH=\"/usr/bin:/bin:$PATH\" exec /opt/orca/bin/orca-git-as \"$@\" 2> >(grep -v '^orca-git-as: no teammate identity' >&2)\n fi\n ;;\nesac\nexec \"$real\" \"$@\"\n"} export const SOURCE_BUILD_SCRIPT: string = "#!/usr/bin/env bash\n# Golden build from source, run by the Worker inside the build sandbox: orcad + the orca CLI from one\n# commit of the Orca repo (cloud/integration carries host RPCs no upstream release has), then the same\n# provision-golden.sh every image uses. Inputs (env):\n# ORCA_SRC_SHA (40-hex) and either ORCA_SRC_DIR (source already uploaded) or ORCA_SRC_REPO\n# (https://github.com//) + ORCA_SRC_AUTH (an\n# `Authorization: Basic …` header value for a 1 h read-only installation token; never printed),\n# ORCA_PROVISION_SCRIPT (base64 of provision-golden.sh) + everything provision-golden.sh reads.\nset -euo pipefail\n# Vercel can report a detached build command as still running after it exits, so the outcome is also\n# a file the caller polls: /tmp/source-build.exit (exit code), /tmp/source-build.report (the\n# provision report line).\nrm -f /tmp/source-build.exit /tmp/source-build.report\ntrap 'echo $? >/tmp/source-build.exit' EXIT\nlog() { printf '[source-build] %s\\n' \"$*\" >&2; }\nstart=$(date +%s)\n[[ \"$ORCA_SRC_SHA\" =~ ^[0-9a-f]{40}$ ]] || { log 'ORCA_SRC_SHA must be a full commit sha'; exit 2; }\n\nlog 'build tools'\nif command -v apt-get >/dev/null; then\n # Transient mirror errors and dpkg lock contention made apt exit 100 (2 of ~10 golden builds):\n # retry downloads and wait for the lock instead of failing the build.\n printf 'Acquire::Retries \"5\";\\nDPkg::Lock::Timeout \"180\";\\n' | sudo tee /etc/apt/apt.conf.d/80-orca-retries >/dev/null\n sudo apt-get update -qq\n sudo DEBIAN_FRONTEND=noninteractive apt-get install -y -qq --no-install-recommends build-essential python3 git ca-certificates >/dev/null\nelse\n sudo dnf install -y -q gcc gcc-c++ make tar gzip python3 git >/dev/null\nfi\nsudo corepack enable >/dev/null 2>&1 || true\n\nsrc=\"$HOME/orca-src\"\nif [ -n \"${ORCA_SRC_DIR:-}\" ]; then\n # Operator rotation (image/rotate-golden-from-source.ts) uploaded `git archive ` here already.\n log \"uploaded source for $ORCA_SRC_SHA\"\n src=\"$ORCA_SRC_DIR\"\n cd \"$src\" && test -f package.json\n git init -q && git add -A && git -c user.email=build@orca -c user.name=build commit -qm \"$ORCA_SRC_SHA\"\nelse\n log \"fetch $ORCA_SRC_SHA\"\n rm -rf \"$src\" && mkdir -p \"$src\" && cd \"$src\"\n git init -q\n # The header lives only in this one command's config, not in .git/config.\n git -c \"http.https://github.com/.extraheader=$ORCA_SRC_AUTH\" fetch -q --depth 1 \"$ORCA_SRC_REPO\" \"$ORCA_SRC_SHA\"\n unset ORCA_SRC_AUTH\n git -c advice.detachedHead=false checkout -q FETCH_HEAD\n test \"$(git rev-parse HEAD)\" = \"$ORCA_SRC_SHA\"\nfi\n\n# The image files come from this commit too (VM scripts, provision, manifest pins). The env the\n# caller passed is only a fallback for commits from before commit-provision-env.mjs existed.\nimage_dir=\"$src/cloud/apps/sandbox-control/image\"\nif [ -f \"$image_dir/commit-provision-env.mjs\" ]; then\n node \"$image_dir/commit-provision-env.mjs\" \"$image_dir\" >/tmp/commit-provision.env\n # shellcheck disable=SC1091\n . /tmp/commit-provision.env\n rm -f /tmp/commit-provision.env\n log \"image files from $ORCA_SRC_SHA\"\nfi\n\nlog 'build orcad + CLI'\nexport CI=1 ELECTRON_SKIP_BINARY_DOWNLOAD=1 PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD=1\ncorepack pnpm install --frozen-lockfile >/tmp/src-install.log 2>&1 || { tail -40 /tmp/src-install.log >&2; exit 1; }\ncorepack pnpm -C mobile install --frozen-lockfile >/tmp/src-mobile.log 2>&1 || { tail -40 /tmp/src-mobile.log >&2; exit 1; }\ncorepack pnpm build:mobile-web >/tmp/src-mobile-web.log 2>&1 || { tail -40 /tmp/src-mobile-web.log >&2; exit 1; }\ncorepack pnpm build:orcad >/tmp/src-orcad.log 2>&1 || { tail -60 /tmp/src-orcad.log >&2; exit 1; }\ncorepack pnpm build:cli >/tmp/src-cli.log 2>&1 || { tail -40 /tmp/src-cli.log >&2; exit 1; }\nmkdir -p out/orca-cli\nnode_modules/.bin/esbuild out/cli/index.js --bundle --platform=node --target=node22 --format=cjs \\\n --outfile=out/orca-cli/orca-cli.cjs --log-level=error\nprintf '%s\\n' \"$ORCA_SRC_SHA\" >out/orcad/SOURCE_COMMIT\ntar czf /tmp/orcad.tgz -C out orcad runtimes orca-cli\nlog \"built in $(( $(date +%s) - start ))s\"\n\nexport ORCAD_BUNDLE_URL=file:///tmp/orcad.tgz\nORCAD_BUNDLE_SHA256=\"$(sha256sum /tmp/orcad.tgz | cut -d' ' -f1)\"\nexport ORCAD_BUNDLE_SHA256\ncd \"$HOME\"\nprintf '%s' \"$ORCA_PROVISION_SCRIPT\" | base64 -d >/tmp/provision-golden.sh\nunset ORCA_PROVISION_SCRIPT\nbash /tmp/provision-golden.sh | tee /tmp/source-build.report\n# Build leftovers stay out of the image.\nrm -rf \"$src\" \"$HOME/.local/share/pnpm\" \"$HOME/.cache/pnpm\" /tmp/orcad.tgz /tmp/provision-golden.sh /tmp/src-*.log\nlog \"done in $(( $(date +%s) - start ))s\"\n" -export const ENVIRONMENT_BUILD_SCRIPT: string = "#!/usr/bin/env bash\n# Environment build (\"Cloud Computer\"), run by the control plane in a VM booted from the golden image.\n# Clones every repo, runs the org's install script once with `set -euo pipefail`, then records what it\n# built from (commit + lockfile blob ids per repo) so the control plane can tell when a rebuild is due.\n# Everything printed here streams live to the desktop build log.\n#\n# Env from the control plane (validated there): ORCA_BUILD_REPOS (`|||\n# ` lines: each private repo gets its own placeholder the egress swaps), ORCA_INSTALL_SCRIPT_B64, ORCA_LOCKFILES (space list), optional ORCA_GIT_EXTRAHEADER, plus\n# the org secrets the environment names. `::orca-step:: ` lines mark progress.\n# Exit codes: 10 clone, 20 install script, 30 recording the result.\nset -uo pipefail\numask 022\n# One stream: the provider replays stdout and stderr separately after the fact, so a failed build's\n# log would read out of order. `::orca-error::` lines carry Orca's own failure explanations.\nexec 2>&1\nOUT=/tmp/orca-build\nROOT=/vercel/sandbox/repos\nmkdir -p \"$OUT\" \"$ROOT\"\nstep() { printf '\\n::orca-step:: %s\\n' \"$1\"; }\nstarted=$(date +%s)\nexport PATH=\"/opt/orca/tools/bin:/opt/orca/bin:$PATH\"\nexport ORCA_REPOS_ROOT=\"$ROOT\" ORCA_ENVIRONMENT_BUILD=1 CI=1 GIT_TERMINAL_PROMPT=0\nrepos() { printf '%s\\n' \"$ORCA_BUILD_REPOS\"; }\n\n# Tell the script author (often an agent) what they are installing onto.\npm=$(for c in apt-get dnf yum apk; do command -v \"$c\" >/dev/null 2>&1 && { echo \"$c\"; break; }; done)\necho \"Base image: $(. /etc/os-release 2>/dev/null && echo \"$PRETTY_NAME\"), $(nproc) vCPU, package manager: ${pm:-none} (with sudo)\"\n\nstep clone\nfirst=\"\"\nwhile IFS='|' read -r url branch dir header; do\n [ -n \"$url\" ] || continue\n dest=\"$ROOT/$dir\"\n [ -n \"$first\" ] || first=\"$dest\"\n # The egress layer swaps the placeholder for a short-lived repo token; nothing real is on disk,\n # and the header is never written to the repo's config.\n git_auth=()\n [ -z \"${header:-}\" ] || git_auth=(-c \"http.https://github.com/.extraheader=$header\")\n echo \"Cloning $url${branch:+ ($branch)}\"\n rm -rf -- \"$dest\"\n # The clone's own error shows only when it really failed (an empty repo is recovered below).\n if ! git \"${git_auth[@]}\" clone --quiet ${branch:+--branch \"$branch\"} -- \"$url\" \"$dest\" 2>\"$OUT/clone.err\"; then\n refs=0\n git \"${git_auth[@]}\" ls-remote --exit-code -- \"$url\" >/dev/null 2>&1 || refs=$?\n if [ -n \"$branch\" ] && [ \"$refs\" -eq 2 ]; then\n # Reachable but no refs at all (ls-remote exits 2): a repo with no commits yet.\n echo \"$url has no commits yet; starting it empty on $branch.\"\n rm -rf -- \"$dest\"\n { git \"${git_auth[@]}\" clone --quiet -- \"$url\" \"$dest\" 2>/dev/null && git -C \"$dest\" checkout --quiet -b \"$branch\"; } || exit 10\n else\n cat \"$OUT/clone.err\"\n echo \"::orca-error:: Could not clone $url${branch:+ at $branch}. Check that the branch exists and Orca Cloud can reach the repository.\" \n exit 10\n fi\n fi\n git -C \"$dest\" log -1 --format=' at %h %s' 2>/dev/null || echo ' (no commits yet)'\ndone < <(repos)\n\nstep install\nprintf '%s' \"${ORCA_INSTALL_SCRIPT_B64:-}\" | base64 -d >\"$OUT/install.sh\"\nif [ -s \"$OUT/install.sh\" ]; then\n echo \"Running the install script in ${first:-$ROOT}\"\n (cd \"${first:-$ROOT}\" && exec bash -euo pipefail \"$OUT/install.sh\") /dev/null)\" || continue\n git -C \"$dest\" ls-files --others --ignored --exclude-standard --directory 2>/dev/null \\\n | sed 's#/$##' | grep -E \"$deps_re\" | head -n 500 >\"$common/orca-env-deps\" || true\n if [ -n \"${ORCA_DEPS_HOOK_B64:-}\" ]; then\n # A relative core.hooksPath (husky: .husky/_) names a gitignored folder a new worktree lacks; pin\n # it to the primary checkout so every worktree runs the same hooks, ours included.\n rel=\"$(git -C \"$dest\" config --get core.hooksPath 2>/dev/null || true)\"\n case \"$rel\" in '' | /*) ;; *) git -C \"$dest\" config core.hooksPath \"$dest/$rel\" ;; esac\n hooks=\"$(git -C \"$dest\" rev-parse --path-format=absolute --git-path hooks)\"\n mkdir -p \"$hooks\"\n if [ -e \"$hooks/post-checkout\" ] && ! grep -q 'orca-env-deps' \"$hooks/post-checkout\"; then\n mv -- \"$hooks/post-checkout\" \"$hooks/post-checkout.orca-chained\"\n fi\n printf '%s' \"$ORCA_DEPS_HOOK_B64\" | base64 -d >\"$hooks/post-checkout\" && chmod 0755 \"$hooks/post-checkout\"\n fi\n n=$(wc -l <\"$common/orca-env-deps\" | tr -d ' ')\n [ \"$n\" -gt 0 ] && echo \"$dir: $n installed folder(s) carried into new workspaces.\"\ndone < <(repos)\n{\n printf '{\"durationSec\":%d,\"repos\":[' \"$(( $(date +%s) - started ))\"\n sep=\"\"\n while IFS='|' read -r url branch dir _; do\n [ -n \"$url\" ] || continue\n dest=\"$ROOT/$dir\"\n commit=$(git -C \"$dest\" rev-parse --verify --quiet HEAD 2>/dev/null || true)\n head=$(git -C \"$dest\" symbolic-ref --quiet --short HEAD 2>/dev/null || true)\n printf '%s{\"url\":\"%s\",\"dir\":\"%s\",\"branch\":\"%s\",\"commit\":\"%s\",\"lockfiles\":{' \"$sep\" \"$url\" \"$dir\" \"$head\" \"$commit\"\n lsep=\"\"\n if [ -n \"$commit\" ]; then\n for f in ${ORCA_LOCKFILES:-}; do\n blob=$(git -C \"$dest\" rev-parse --verify --quiet \"HEAD:$f\" 2>/dev/null || true)\n if [ -n \"$blob\" ]; then printf '%s\"%s\":\"%s\"' \"$lsep\" \"$f\" \"$blob\"; lsep=\",\"; fi\n done\n fi\n printf '}}'\n sep=\",\"\n done < <(repos)\n printf '],\"diskUsedBytes\":%s,\"diskTotalBytes\":%s}\\n' \\\n \"$(df -B1 --output=used / | tail -n 1 | tr -d ' ')\" \"$(df -B1 --output=size / | tail -n 1 | tr -d ' ')\"\n} >\"$OUT/result.json\" || exit 30\n# Nothing from this VM's own session belongs in the image, only what the script installed.\nrm -rf -- \"$OUT/install.sh\" \"$HOME/.bash_history\" \"$HOME/.orcad-data\" \"$HOME/.orca-sandbox\"\necho \"Disk used: $(df -h --output=used / | tail -n 1 | tr -d ' ') of $(df -h --output=size / | tail -n 1 | tr -d ' ')\"\n" +export const ENVIRONMENT_BUILD_SCRIPT: string = "#!/usr/bin/env bash\n# Environment build (\"Cloud Computer\"), run by the control plane in a VM booted from the golden image.\n# Clones every repo, runs the org's install script once with `set -euo pipefail`, then records what it\n# built from (commit + lockfile blob ids per repo) so the control plane can tell when a rebuild is due.\n# Everything printed here streams live to the desktop build log.\n#\n# Env from the control plane (validated there): ORCA_BUILD_REPOS (`|||\n# ` lines: each private repo gets its own placeholder the egress swaps), ORCA_INSTALL_SCRIPT_B64, ORCA_LOCKFILES (space list), optional ORCA_GIT_EXTRAHEADER and ORCA_CLONE_FILTER, plus\n# the org secrets the environment names. `::orca-step:: ` lines mark progress.\n# Exit codes: 10 clone, 20 install script, 30 recording the result.\nset -uo pipefail\numask 022\n# One stream: the provider replays stdout and stderr separately after the fact, so a failed build's\n# log would read out of order. `::orca-error::` lines carry Orca's own failure explanations.\nexec 2>&1\nOUT=/tmp/orca-build\nROOT=/vercel/sandbox/repos\nmkdir -p \"$OUT\" \"$ROOT\"\nstep() { printf '\\n::orca-step:: %s\\n' \"$1\"; }\nstarted=$(date +%s)\nexport PATH=\"/opt/orca/tools/bin:/opt/orca/bin:$PATH\"\nexport ORCA_REPOS_ROOT=\"$ROOT\" ORCA_ENVIRONMENT_BUILD=1 CI=1 GIT_TERMINAL_PROMPT=0\nrepos() { printf '%s\\n' \"$ORCA_BUILD_REPOS\"; }\n\n# Tell the script author (often an agent) what they are installing onto.\npm=$(for c in apt-get dnf yum apk; do command -v \"$c\" >/dev/null 2>&1 && { echo \"$c\"; break; }; done)\necho \"Base image: $(. /etc/os-release 2>/dev/null && echo \"$PRETTY_NAME\"), $(nproc) vCPU, package manager: ${pm:-none} (with sudo)\"\n\nstep clone\nfirst=\"\"\nwhile IFS='|' read -r url branch dir header; do\n [ -n \"$url\" ] || continue\n dest=\"$ROOT/$dir\"\n [ -n \"$first\" ] || first=\"$dest\"\n # The egress layer swaps the placeholder for a short-lived repo token; nothing real is on disk,\n # and the header is never written to the repo's config.\n git_auth=()\n [ -z \"${header:-}\" ] || git_auth=(-c \"http.https://github.com/.extraheader=$header\")\n echo \"Cloning $url${branch:+ ($branch)}\"\n rm -rf -- \"$dest\"\n # The clone's own error shows only when it really failed (an empty repo is recovered below).\n # ORCA_CLONE_FILTER (automatic environments: blob:none) keeps history and trees, not every old blob.\n if ! git \"${git_auth[@]}\" clone --quiet ${ORCA_CLONE_FILTER:+--filter=\"$ORCA_CLONE_FILTER\"} ${branch:+--branch \"$branch\"} -- \"$url\" \"$dest\" 2>\"$OUT/clone.err\"; then\n refs=0\n git \"${git_auth[@]}\" ls-remote --exit-code -- \"$url\" >/dev/null 2>&1 || refs=$?\n if [ -n \"$branch\" ] && [ \"$refs\" -eq 2 ]; then\n # Reachable but no refs at all (ls-remote exits 2): a repo with no commits yet.\n echo \"$url has no commits yet; starting it empty on $branch.\"\n rm -rf -- \"$dest\"\n { git \"${git_auth[@]}\" clone --quiet -- \"$url\" \"$dest\" 2>/dev/null && git -C \"$dest\" checkout --quiet -b \"$branch\"; } || exit 10\n else\n cat \"$OUT/clone.err\"\n echo \"::orca-error:: Could not clone $url${branch:+ at $branch}. Check that the branch exists and Orca Cloud can reach the repository.\" \n exit 10\n fi\n fi\n git -C \"$dest\" log -1 --format=' at %h %s' 2>/dev/null || echo ' (no commits yet)'\ndone < <(repos)\n\nstep install\nprintf '%s' \"${ORCA_INSTALL_SCRIPT_B64:-}\" | base64 -d >\"$OUT/install.sh\"\nif [ -s \"$OUT/install.sh\" ]; then\n echo \"Running the install script in ${first:-$ROOT}\"\n (cd \"${first:-$ROOT}\" && exec bash -euo pipefail \"$OUT/install.sh\") /dev/null)\" || continue\n git -C \"$dest\" ls-files --others --ignored --exclude-standard --directory 2>/dev/null \\\n | sed 's#/$##' | grep -E \"$deps_re\" | head -n 500 >\"$common/orca-env-deps\" || true\n if [ -n \"${ORCA_DEPS_HOOK_B64:-}\" ]; then\n # A relative core.hooksPath (husky: .husky/_) names a gitignored folder a new worktree lacks; pin\n # it to the primary checkout so every worktree runs the same hooks, ours included.\n rel=\"$(git -C \"$dest\" config --get core.hooksPath 2>/dev/null || true)\"\n case \"$rel\" in '' | /*) ;; *) git -C \"$dest\" config core.hooksPath \"$dest/$rel\" ;; esac\n hooks=\"$(git -C \"$dest\" rev-parse --path-format=absolute --git-path hooks)\"\n mkdir -p \"$hooks\"\n if [ -e \"$hooks/post-checkout\" ] && ! grep -q 'orca-env-deps' \"$hooks/post-checkout\"; then\n mv -- \"$hooks/post-checkout\" \"$hooks/post-checkout.orca-chained\"\n fi\n printf '%s' \"$ORCA_DEPS_HOOK_B64\" | base64 -d >\"$hooks/post-checkout\" && chmod 0755 \"$hooks/post-checkout\"\n fi\n n=$(wc -l <\"$common/orca-env-deps\" | tr -d ' ')\n [ \"$n\" -gt 0 ] && echo \"$dir: $n installed folder(s) carried into new workspaces.\"\ndone < <(repos)\n{\n printf '{\"durationSec\":%d,\"repos\":[' \"$(( $(date +%s) - started ))\"\n sep=\"\"\n while IFS='|' read -r url branch dir _; do\n [ -n \"$url\" ] || continue\n dest=\"$ROOT/$dir\"\n commit=$(git -C \"$dest\" rev-parse --verify --quiet HEAD 2>/dev/null || true)\n head=$(git -C \"$dest\" symbolic-ref --quiet --short HEAD 2>/dev/null || true)\n printf '%s{\"url\":\"%s\",\"dir\":\"%s\",\"branch\":\"%s\",\"commit\":\"%s\",\"lockfiles\":{' \"$sep\" \"$url\" \"$dir\" \"$head\" \"$commit\"\n lsep=\"\"\n if [ -n \"$commit\" ]; then\n for f in ${ORCA_LOCKFILES:-}; do\n blob=$(git -C \"$dest\" rev-parse --verify --quiet \"HEAD:$f\" 2>/dev/null || true)\n if [ -n \"$blob\" ]; then printf '%s\"%s\":\"%s\"' \"$lsep\" \"$f\" \"$blob\"; lsep=\",\"; fi\n done\n fi\n printf '}}'\n sep=\",\"\n done < <(repos)\n printf '],\"diskUsedBytes\":%s,\"diskTotalBytes\":%s}\\n' \\\n \"$(df -B1 --output=used / | tail -n 1 | tr -d ' ')\" \"$(df -B1 --output=size / | tail -n 1 | tr -d ' ')\"\n} >\"$OUT/result.json\" || exit 30\n# Nothing from this VM's own session belongs in the image, only what the script installed.\nrm -rf -- \"$OUT/install.sh\" \"$HOME/.bash_history\" \"$HOME/.orcad-data\" \"$HOME/.orca-sandbox\"\necho \"Disk used: $(df -h --output=used / | tail -n 1 | tr -d ' ') of $(df -h --output=size / | tail -n 1 | tr -d ' ')\"\n" export const ENVIRONMENT_DEPS_HOOK: string = "#!/usr/bin/env bash\n# Installed by Orca environment builds as the repo's post-checkout hook. When git creates a new linked\n# worktree (`git worktree add` passes the null commit as the previous HEAD), give it the dependency\n# folders the build installed in the primary checkout, as hard links: near-instant, real paths (not\n# symlinks, so bundlers and native modules behave). Hard links share file contents: tools that rewrite\n# a file in place inside these folders change it for every worktree on this VM (one workspace per VM).\n# Any post-checkout hook the repo already had runs afterwards, unchanged.\nprev=\"${1:-}\"\nhere=\"$(dirname \"$0\")\"\nif [ \"$prev\" = \"0000000000000000000000000000000000000000\" ] && [ \"${ORCA_SKIP_DEPS_LINK:-}\" != 1 ]; then\n common=\"$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null || true)\"\n top=\"$(git rev-parse --show-toplevel 2>/dev/null || true)\"\n primary=\"$(dirname \"$common\")\"\n list=\"$common/orca-env-deps\"\n if [ -n \"$top\" ] && [ \"$top\" != \"$primary\" ] && [ -f \"$list\" ]; then\n started=$(date +%s%N)\n linked=0\n while IFS= read -r rel; do\n case \"$rel\" in '' | /* | *..*) continue ;; esac\n [ -e \"$primary/$rel\" ] && [ ! -e \"$top/$rel\" ] || continue\n mkdir -p \"$(dirname \"$top/$rel\")\"\n if [ -d \"$primary/$rel\" ]; then\n if ! cp -al -- \"$primary/$rel\" \"$top/$rel\" 2>/dev/null; then\n # A partial hard-link copy would make the fallback nest inside it: start clean.\n rm -rf -- \"$top/$rel\"\n cp -a -- \"$primary/$rel\" \"$top/$rel\" 2>/dev/null || { rm -rf -- \"$top/$rel\"; continue; }\n fi\n else\n cp -a -- \"$primary/$rel\" \"$top/$rel\" 2>/dev/null || continue\n fi\n linked=$((linked + 1))\n done <\"$list\"\n if [ \"$linked\" -gt 0 ]; then\n echo \"Orca: reused $linked installed dependency folder(s) from the environment build ($(( ($(date +%s%N) - started) / 1000000 )) ms).\" >&2\n fi\n fi\nfi\nif [ -x \"$here/post-checkout.orca-chained\" ]; then\n if head -n 1 \"$here/post-checkout.orca-chained\" | grep -Eq '^#!.*(ba|da|z)?sh'; then\n # Sourced, so $0 still names `post-checkout` (husky v9 finds the user's hook by basename \"$0\").\n ( . \"$here/post-checkout.orca-chained\" \"$@\" )\n exit $?\n fi\n exec \"$here/post-checkout.orca-chained\" \"$@\"\nfi\nexit 0\n" -export const WORKSPACE_PRELUDE_SCRIPT: string = "#!/usr/bin/env bash\n# Runs right before orca-sandbox-start on a workspace's first boot. Prints only to stderr: the start\n# script's last stdout line is the orcad recipe line the control plane parses.\n#\n# - Booted from an environment build (ORCA_ENV_REPO_DIR set): the repo is already cloned with its\n# dependencies installed under /vercel/sandbox/repos. Link it as the project (a link, not a move,\n# so absolute paths baked into installed dependencies keep working). No fetch when the build is\n# already on the requested branch: Orca fetches the base right before it adds the workspace's\n# worktree, so a fetch here would only delay orcad (measured ~0.5-1 s). Another branch is fetched\n# and checked out; if that fails the workspace still opens at the build's commit.\n# - Otherwise clone ORCA_REPO_URL here so a repo with no commits yet also opens: it gets an empty\n# first commit on the requested branch, which Orca needs to create the workspace's worktree.\n# The clone is blobless (--filter=blob:none): history and trees, file contents only for the\n# checkout. A full clone of a large repo (stablyai/orca, ~2.7 GB) outran the 120 s start timeout.\n# With ORCA_CLONE_BACKGROUND=1 the clone runs detached after this script returns, so orcad starts\n# at once; it reports through $CLONE_DIR (state: running | done | failed , plus git's\n# --progress output) and the control plane's GET /v1/sandboxes/:id/clone reads it.\nset -uo pipefail\nP=/vercel/sandbox/project\nROOT=/vercel/sandbox/repos\nCLONE_DIR=\"$HOME/.orca-sandbox/clone\"\n# A stuck clone fails with a reason instead of hanging forever.\nCLONE_TIMEOUT_S=\"${ORCA_CLONE_TIMEOUT_S:-900}\"\nexport GIT_TERMINAL_PROMPT=0\nauth=()\nif [ -n \"${ORCA_GIT_EXTRAHEADER:-}\" ]; then\n auth=(-c \"http.https://github.com/.extraheader=$ORCA_GIT_EXTRAHEADER\")\nfi\nref=\"${ORCA_REPO_REF:-}\"\n\nfirst_commit() {\n if ! git -C \"$P\" rev-parse --verify --quiet HEAD >/dev/null; then\n git -C \"$P\" checkout --quiet -B \"${ref:-main}\" 2>/dev/null || true\n git -C \"$P\" -c user.name='Orca' -c user.email='cloud@onorca.dev' \\\n commit --quiet --allow-empty -m 'Initial commit' && echo 'Empty repository: created a first commit.'\n fi\n}\n\n# Clones into $P (which may already exist, empty). Progress goes to stderr.\nclone_repo() {\n local opts=(--filter=blob:none --progress) status\n timeout \"$CLONE_TIMEOUT_S\" git ${auth[@]+\"${auth[@]}\"} clone \"${opts[@]}\" ${ref:+--branch \"$ref\"} -- \"$ORCA_REPO_URL\" \"$P\"\n status=$?\n if [ \"$status\" -ne 0 ]; then\n [ \"$status\" -eq 124 ] && return 124\n # Empty it in place: the start script must keep seeing the directory, or it would clone itself.\n find \"$P\" -mindepth 1 -delete 2>/dev/null || true\n # Branch missing (or a repo with no commits): clone the default branch, then switch.\n timeout \"$CLONE_TIMEOUT_S\" git ${auth[@]+\"${auth[@]}\"} clone \"${opts[@]}\" -- \"$ORCA_REPO_URL\" \"$P\" || return \"$?\"\n if [ -n \"$ref\" ] && ! git -C \"$P\" checkout --quiet \"$ref\" -- 2>/dev/null; then\n git -C \"$P\" checkout --quiet -b \"$ref\" -- || true\n fi\n fi\n first_commit\n}\n\n# The reason the control plane shows: never the raw log (it may echo URLs).\nclone_failure_reason() {\n local status=\"$1\" log=\"$2\"\n if [ \"$status\" -eq 124 ]; then\n echo 'clone_timeout'\n elif grep -qiE 'could not read Username|authentication failed|repository not found|403|denied' \"$log\" 2>/dev/null; then\n echo 'repo_unreachable'\n elif grep -qiE 'no space left' \"$log\" 2>/dev/null; then\n echo 'disk_full'\n else\n echo 'clone_failed'\n fi\n}\n\nif [ ! -e \"$P\" ] && [ -n \"${ORCA_ENV_REPO_DIR:-}\" ] && [ -d \"$ROOT/$ORCA_ENV_REPO_DIR/.git\" ]; then\n ln -s \"$ROOT/$ORCA_ENV_REPO_DIR\" \"$P\"\n if [ -n \"$ref\" ] && [ \"$(git -C \"$P\" symbolic-ref --quiet --short HEAD 2>/dev/null)\" != \"$ref\" ]; then\n if timeout 60 git \"${auth[@]}\" -C \"$P\" fetch --quiet origin \"+refs/heads/$ref:refs/remotes/origin/$ref\"; then\n # -f: the install may have rewritten tracked files (a lockfile); the branch's version wins.\n git -C \"$P\" checkout --quiet -f -B \"$ref\" \"origin/$ref\" -- ||\n echo \"Could not switch to $ref; the workspace starts at the build's commit.\"\n else\n echo \"Could not fetch $ref; the workspace starts at the build's commit.\"\n fi\n fi\n first_commit\nelif [ ! -e \"$P\" ] && [ -n \"${ORCA_REPO_URL:-}\" ]; then\n mkdir -p \"$P\" \"$CLONE_DIR\"\n if [ \"${ORCA_CLONE_BACKGROUND:-}\" = 1 ]; then\n echo running >\"$CLONE_DIR/state\"\n : >\"$CLONE_DIR/progress.log\"\n # Detached (own session, no inherited stdio): the start command returns while this runs.\n export -f clone_repo first_commit clone_failure_reason\n export P CLONE_DIR CLONE_TIMEOUT_S ORCA_REPO_URL ref\n export ORCA_PRELUDE_AUTH=\"${ORCA_GIT_EXTRAHEADER:-}\"\n setsid bash -c '\n auth=()\n [ -n \"$ORCA_PRELUDE_AUTH\" ] && auth=(-c \"http.https://github.com/.extraheader=$ORCA_PRELUDE_AUTH\")\n unset ORCA_PRELUDE_AUTH\n clone_repo >>\"$CLONE_DIR/progress.log\" 2>&1\n status=$?\n if [ \"$status\" -eq 0 ]; then\n echo done >\"$CLONE_DIR/state.next\"\n else\n echo \"failed $(clone_failure_reason \"$status\" \"$CLONE_DIR/progress.log\")\" >\"$CLONE_DIR/state.next\"\n fi\n mv -f \"$CLONE_DIR/state.next\" \"$CLONE_DIR/state\"\n ' /dev/null 2>&1 &\n else\n clone_repo 2>\"$CLONE_DIR/progress.log\" || exit 1\n fi\nfi\nexit 0\n" +export const WORKSPACE_PRELUDE_SCRIPT: string = "#!/usr/bin/env bash\n# Runs right before orca-sandbox-start on a workspace's first boot. Prints only to stderr: the start\n# script's last stdout line is the orcad recipe line the control plane parses.\n#\n# - Booted from an environment build (ORCA_ENV_REPO_DIR set): the repo is already cloned with its\n# dependencies installed under /vercel/sandbox/repos. Link it as the project (a link, not a move,\n# so absolute paths baked into installed dependencies keep working). No fetch when the build is\n# already on the requested branch: Orca fetches the base right before it adds the workspace's\n# worktree, so a fetch here would only delay orcad (measured ~0.5-1 s). Another branch is fetched\n# and checked out; if that fails the workspace still opens at the build's commit.\n# - Otherwise clone ORCA_REPO_URL here so a repo with no commits yet also opens: it gets an empty\n# first commit on the requested branch, which Orca needs to create the workspace's worktree.\n# The clone is blobless (--filter=blob:none): history and trees, file contents only for the\n# checkout. A full clone of a large repo (stablyai/orca, ~2.7 GB) outran the 120 s start timeout.\n# With ORCA_CLONE_BACKGROUND=1 the clone runs detached after this script returns, so orcad starts\n# at once; it reports through $CLONE_DIR (state: running | done | failed , plus git's\n# --progress output) and the control plane's GET /v1/sandboxes/:id/clone reads it.\nset -uo pipefail\nP=/vercel/sandbox/project\nROOT=/vercel/sandbox/repos\nCLONE_DIR=\"$HOME/.orca-sandbox/clone\"\n# A stuck clone fails with a reason instead of hanging forever.\nCLONE_TIMEOUT_S=\"${ORCA_CLONE_TIMEOUT_S:-900}\"\nexport GIT_TERMINAL_PROMPT=0\nauth=()\nif [ -n \"${ORCA_GIT_EXTRAHEADER:-}\" ]; then\n auth=(-c \"http.https://github.com/.extraheader=$ORCA_GIT_EXTRAHEADER\")\nfi\nref=\"${ORCA_REPO_REF:-}\"\n\nfirst_commit() {\n if ! git -C \"$P\" rev-parse --verify --quiet HEAD >/dev/null; then\n git -C \"$P\" checkout --quiet -B \"${ref:-main}\" 2>/dev/null || true\n git -C \"$P\" -c user.name='Orca' -c user.email='cloud@onorca.dev' \\\n commit --quiet --allow-empty -m 'Initial commit' && echo 'Empty repository: created a first commit.'\n fi\n}\n\n# Clones into $P (which may already exist, empty). Progress goes to stderr.\nclone_repo() {\n local opts=(--filter=blob:none --progress) status\n timeout \"$CLONE_TIMEOUT_S\" git ${auth[@]+\"${auth[@]}\"} clone \"${opts[@]}\" ${ref:+--branch \"$ref\"} -- \"$ORCA_REPO_URL\" \"$P\"\n status=$?\n if [ \"$status\" -ne 0 ]; then\n [ \"$status\" -eq 124 ] && return 124\n # Empty it in place: the start script must keep seeing the directory, or it would clone itself.\n find \"$P\" -mindepth 1 -delete 2>/dev/null || true\n # Branch missing (or a repo with no commits): clone the default branch, then switch.\n timeout \"$CLONE_TIMEOUT_S\" git ${auth[@]+\"${auth[@]}\"} clone \"${opts[@]}\" -- \"$ORCA_REPO_URL\" \"$P\" || return \"$?\"\n if [ -n \"$ref\" ] && ! git -C \"$P\" checkout --quiet \"$ref\" -- 2>/dev/null; then\n git -C \"$P\" checkout --quiet -b \"$ref\" -- || true\n fi\n fi\n first_commit\n}\n\n# The reason the control plane shows: never the raw log (it may echo URLs).\nclone_failure_reason() {\n local status=\"$1\" log=\"$2\"\n if [ \"$status\" -eq 124 ]; then\n echo 'clone_timeout'\n elif grep -qiE 'could not read Username|authentication failed|repository not found|403|denied' \"$log\" 2>/dev/null; then\n echo 'repo_unreachable'\n elif grep -qiE 'no space left' \"$log\" 2>/dev/null; then\n echo 'disk_full'\n else\n echo 'clone_failed'\n fi\n}\n\n\n# Brings a prebuilt checkout (environment build) up to date: fetches only what changed on the target\n# branch (ORCA_REPO_REF, else the build's branch) and checks it out. A branch the remote doesn't have\n# yet (a new workspace branch) starts from the build's branch, freshly fetched. Progress goes to stderr.\nupdate_repo() {\n local base target status\n base=\"$(git -C \"$P\" symbolic-ref --quiet --short HEAD 2>/dev/null || true)\"\n target=\"${ref:-$base}\"\n [ -n \"$target\" ] || return 0\n timeout \"$CLONE_TIMEOUT_S\" git ${auth[@]+\"${auth[@]}\"} -C \"$P\" fetch --progress origin \"+refs/heads/$target:refs/remotes/origin/$target\"\n status=$?\n if [ \"$status\" -eq 0 ]; then\n # -f: the install may have rewritten tracked files (a lockfile); the branch's version wins.\n git -C \"$P\" checkout --quiet -f -B \"$target\" \"origin/$target\" --\n return $?\n fi\n [ \"$status\" -eq 124 ] && return 124\n { [ -n \"$base\" ] && [ \"$base\" != \"$target\" ]; } || return \"$status\"\n timeout \"$CLONE_TIMEOUT_S\" git ${auth[@]+\"${auth[@]}\"} -C \"$P\" fetch --progress origin \"+refs/heads/$base:refs/remotes/origin/$base\" || return $?\n git -C \"$P\" checkout --quiet -f -B \"$target\" \"origin/$base\" --\n}\n\n# Runs clone_repo or update_repo detached (own session, no inherited stdio), so the start command\n# returns while it runs; $CLONE_DIR/state reads running, then done or \"failed \".\nrun_detached() {\n echo running >\"$CLONE_DIR/state\"\n : >\"$CLONE_DIR/progress.log\"\n export -f clone_repo update_repo first_commit clone_failure_reason\n export P CLONE_DIR CLONE_TIMEOUT_S ORCA_REPO_URL ref\n export ORCA_PRELUDE_AUTH=\"${ORCA_GIT_EXTRAHEADER:-}\" ORCA_PRELUDE_STEP=\"$1\"\n setsid bash -c '\n auth=()\n [ -n \"$ORCA_PRELUDE_AUTH\" ] && auth=(-c \"http.https://github.com/.extraheader=$ORCA_PRELUDE_AUTH\")\n unset ORCA_PRELUDE_AUTH\n \"$ORCA_PRELUDE_STEP\" >>\"$CLONE_DIR/progress.log\" 2>&1\n status=$?\n if [ \"$status\" -eq 0 ]; then\n echo done >\"$CLONE_DIR/state.next\"\n elif [ \"$ORCA_PRELUDE_STEP\" = update_repo ]; then\n # Not fatal: the build'\"'\"'s checkout is there, just older. The status says so; the create goes on.\n echo \"done stale\" >\"$CLONE_DIR/state.next\"\n else\n echo \"failed $(clone_failure_reason \"$status\" \"$CLONE_DIR/progress.log\")\" >\"$CLONE_DIR/state.next\"\n fi\n mv -f \"$CLONE_DIR/state.next\" \"$CLONE_DIR/state\"\n ' /dev/null 2>&1 &\n}\n\nif [ ! -e \"$P\" ] && [ -n \"${ORCA_ENV_REPO_DIR:-}\" ] && [ -d \"$ROOT/$ORCA_ENV_REPO_DIR/.git\" ]; then\n ln -s \"$ROOT/$ORCA_ENV_REPO_DIR\" \"$P\"\n if [ \"${ORCA_CLONE_BACKGROUND:-}\" = 1 ]; then\n # The desktop shows this as \"Update repository\" (GET /v1/sandboxes/:id/clone): fetch what changed\n # since the build, in the background. A failure leaves the build's commit, which still opens.\n mkdir -p \"$CLONE_DIR\"\n run_detached update_repo\n elif [ -n \"$ref\" ] && [ \"$(git -C \"$P\" symbolic-ref --quiet --short HEAD 2>/dev/null)\" != \"$ref\" ]; then\n if timeout 60 git \"${auth[@]}\" -C \"$P\" fetch --quiet origin \"+refs/heads/$ref:refs/remotes/origin/$ref\"; then\n # -f: the install may have rewritten tracked files (a lockfile); the branch's version wins.\n git -C \"$P\" checkout --quiet -f -B \"$ref\" \"origin/$ref\" -- ||\n echo \"Could not switch to $ref; the workspace starts at the build's commit.\"\n else\n echo \"Could not fetch $ref; the workspace starts at the build's commit.\"\n fi\n fi\n first_commit\nelif [ ! -e \"$P\" ] && [ -n \"${ORCA_REPO_URL:-}\" ]; then\n mkdir -p \"$P\" \"$CLONE_DIR\"\n if [ \"${ORCA_CLONE_BACKGROUND:-}\" = 1 ]; then\n run_detached clone_repo\n else\n clone_repo 2>\"$CLONE_DIR/progress.log\" || exit 1\n fi\nfi\nexit 0\n" diff --git a/cloud/apps/sandbox-control/image/vm/orca-sandbox-start b/cloud/apps/sandbox-control/image/vm/orca-sandbox-start index 32e7308a1ab..349492fcae7 100755 --- a/cloud/apps/sandbox-control/image/vm/orca-sandbox-start +++ b/cloud/apps/sandbox-control/image/vm/orca-sandbox-start @@ -178,9 +178,12 @@ ca_env=(NODE_USE_SYSTEM_CA="${NODE_USE_SYSTEM_CA:-1}") for name in NODE_EXTRA_CA_CERTS SSL_CERT_FILE; do if [ -n "${!name:-}" ]; then ca_env+=("$name=${!name}"); fi done +# Ports panel: programs under $ORCA_HOME are the image's own services, and 23456 is Vercel's +# sandbox-init (root, pid invisible to this user); neither is listed as the user's port. env -i HOME="$HOME" USER="$(id -un)" LANG=C.UTF-8 TERM=xterm-256color "${ca_env[@]}" \ PATH="$ORCA_HOME/tools/bin:$ORCA_HOME/bin:$(dirname "$system_node"):/usr/local/bin:/usr/bin:/bin" \ ORCA_USER_DATA="$HOME/.orcad-data" ORCA_SANDBOX_ID="$ORCA_SANDBOX_ID" "${managed_env[@]}" \ + ORCA_HOST_MANAGED_LISTENER_PATHS="$ORCA_HOME" ORCA_HOST_MANAGED_UNOWNED_PORTS=23456 \ NODE_COMPILE_CACHE="$ORCA_HOME/compile-cache" ORCA_ORCAD_STARTUP_QUALIFICATION_DIR="$ORCA_HOME/startup-qualification" \ ORCA_SESSION_ENV_NAMES="${secret_names[*]}" "${agent_env[@]}" \ setsid nohup "$node" "$ORCA_HOME/bin/orcad-boot" --code-cache "$ORCA_HOME/compile-cache/orcad-server.v8" \ diff --git a/cloud/apps/sandbox-control/migrations/0048_agent_credential_verified.sql b/cloud/apps/sandbox-control/migrations/0048_agent_credential_verified.sql new file mode 100644 index 00000000000..d0f0eefcc48 --- /dev/null +++ b/cloud/apps/sandbox-control/migrations/0048_agent_credential_verified.sql @@ -0,0 +1,4 @@ +-- Last time the control plane's own auth check passed for this credential (POST +-- /v1/agent-credentials/claude/verify, or the check behind a provider 401). Recent passes answer verify +-- without calling the provider again. +ALTER TABLE agent_credentials ADD COLUMN verified_at INTEGER; diff --git a/cloud/apps/sandbox-control/migrations/0049_auto_environments.sql b/cloud/apps/sandbox-control/migrations/0049_auto_environments.sql new file mode 100644 index 00000000000..d07dcd0dfe1 --- /dev/null +++ b/cloud/apps/sandbox-control/migrations/0049_auto_environments.sql @@ -0,0 +1,8 @@ +-- Automatic environments (src/auto-environments.ts): the first create of a repo that no environment +-- lists makes a default environment for it (just the repo) and builds it in the background, so later +-- creates boot with the repo already checked out. 'org' rows are made or edited by an admin; 'auto' rows +-- were made by the system and are deleted after 14 days without a create (an admin's edit makes them 'org'). +ALTER TABLE environments ADD COLUMN kind TEXT NOT NULL DEFAULT 'org'; +-- Last create that booted from this environment (or asked for one for its repo). +ALTER TABLE environments ADD COLUMN last_used_at INTEGER; +CREATE INDEX environments_kind ON environments (kind, deleted_at); diff --git a/cloud/apps/sandbox-control/migrations/0050_team_presence.sql b/cloud/apps/sandbox-control/migrations/0050_team_presence.sql new file mode 100644 index 00000000000..28ee3094a51 --- /dev/null +++ b/cloud/apps/sandbox-control/migrations/0050_team_presence.sql @@ -0,0 +1,35 @@ +-- Teammate profiles and Pokes (team-presence). Additive; older Workers ignore all of it. +-- +-- member_usage_hours: model spend each member's own client reported, by UTC hour. Filled from the +-- deltas of the cumulative sandboxes.token_usd_micros a client PATCHes, so it accrues from the +-- deploy onward. Compute time comes from usage_outbox and is not copied here. +CREATE TABLE IF NOT EXISTS member_usage_hours ( + account_id TEXT NOT NULL, + user_id TEXT NOT NULL, + hour INTEGER NOT NULL, -- floor(ms / 3_600_000) + token_usd_micros INTEGER NOT NULL DEFAULT 0, + PRIMARY KEY (account_id, user_id, hour) +); + +-- Heatmap reads compute segments per account and time window. +CREATE INDEX IF NOT EXISTS usage_outbox_account_started ON usage_outbox (account_id, started_at); + +-- Pokes are opt-in (Settings → Experimental): a poke goes through only when both people have it on. +CREATE TABLE IF NOT EXISTS member_poke_prefs ( + account_id TEXT NOT NULL, + user_id TEXT NOT NULL, + enabled INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + PRIMARY KEY (account_id, user_id) +); + +CREATE TABLE IF NOT EXISTS member_pokes ( + id TEXT PRIMARY KEY, -- pok_<24 hex> + account_id TEXT NOT NULL, + from_user_id TEXT NOT NULL, + to_user_id TEXT NOT NULL, + created_at INTEGER NOT NULL, + seen_at INTEGER +); +CREATE INDEX IF NOT EXISTS member_pokes_inbox ON member_pokes (account_id, to_user_id, created_at); +CREATE INDEX IF NOT EXISTS member_pokes_sender ON member_pokes (account_id, from_user_id, created_at); diff --git a/cloud/apps/sandbox-control/migrations/0051_workspace_numbers_prefs.sql b/cloud/apps/sandbox-control/migrations/0051_workspace_numbers_prefs.sql new file mode 100644 index 00000000000..329a96abb2d --- /dev/null +++ b/cloud/apps/sandbox-control/migrations/0051_workspace_numbers_prefs.sql @@ -0,0 +1,40 @@ +-- G14: every cloud workspace gets a short number in its account (W-123), allocated from a per-account +-- counter so a number is never reused, even after the row is destroyed. Orgs get a URL slug for links +-- (orca://cloud//W-123). G13: each member's sidebar prefs for cloud workspaces (pins, their +-- order, and the order of sections) live on the account so every device shows the same sidebar. +ALTER TABLE sandboxes ADD COLUMN number INTEGER; + +-- Backfill: existing rows numbered by creation order within their account. +UPDATE sandboxes SET number = ( + SELECT COUNT(*) FROM sandboxes AS earlier + WHERE earlier.account_id = sandboxes.account_id + AND (earlier.created_at < sandboxes.created_at OR (earlier.created_at = sandboxes.created_at AND earlier.id <= sandboxes.id)) +); + +CREATE UNIQUE INDEX sandboxes_account_number ON sandboxes (account_id, number) WHERE number IS NOT NULL; + +CREATE TABLE org_workspace_counters ( + account_id TEXT PRIMARY KEY, + last_number INTEGER NOT NULL +); + +INSERT INTO org_workspace_counters (account_id, last_number) + SELECT account_id, MAX(number) FROM sandboxes GROUP BY account_id; + +CREATE TABLE org_slugs ( + account_id TEXT PRIMARY KEY, + slug TEXT NOT NULL UNIQUE, + created_at INTEGER NOT NULL, + created_by TEXT NOT NULL, + updated_at INTEGER NOT NULL +); + +CREATE TABLE workspace_prefs ( + account_id TEXT NOT NULL, + user_id TEXT NOT NULL, + document TEXT NOT NULL, + revision INTEGER NOT NULL, + updated_at INTEGER NOT NULL, + updated_by_device TEXT, + PRIMARY KEY (account_id, user_id) +); diff --git a/cloud/apps/sandbox-control/migrations/0052_workspace_attachments.sql b/cloud/apps/sandbox-control/migrations/0052_workspace_attachments.sql new file mode 100644 index 00000000000..2fb12f98cce --- /dev/null +++ b/cloud/apps/sandbox-control/migrations/0052_workspace_attachments.sql @@ -0,0 +1,15 @@ +-- Files uploaded through the public API / MCP for an agent to read (G10 attachments). The bytes live +-- on the workspace's own disk (/vercel/sandbox/attachments//, outside the repo); this +-- row lets a message reference the file by id. Additive only. +CREATE TABLE IF NOT EXISTS workspace_attachments ( + id TEXT PRIMARY KEY, + sandbox_id TEXT NOT NULL, + account_id TEXT NOT NULL, + uploaded_by TEXT NOT NULL, + filename TEXT NOT NULL, + content_type TEXT NOT NULL, + byte_size INTEGER NOT NULL, + path TEXT NOT NULL, + created_at INTEGER NOT NULL +); +CREATE INDEX IF NOT EXISTS workspace_attachments_sandbox ON workspace_attachments (sandbox_id, created_at); diff --git a/cloud/apps/sandbox-control/src/agent-credential-checks.ts b/cloud/apps/sandbox-control/src/agent-credential-checks.ts index 0dc07a408bf..2ea5948610d 100644 --- a/cloud/apps/sandbox-control/src/agent-credential-checks.ts +++ b/cloud/apps/sandbox-control/src/agent-credential-checks.ts @@ -1,46 +1,56 @@ // A provider 401 on an Orca-account request (the proxy swapped the real credential in) is a signal, not a // verdict: one transient auth error must not sign a person out of every workspace. Before revoking, the // control plane makes one cheap server-side auth check with the real credential (no tokens spent) and -// revokes only when that also says the credential is dead. Checks are rate-limited per person and agent -// (agent_credentials.checked_at), and every decision is audited (agent_credential_audit). +// revokes only when that also says the credential is dead. The desktop can ask for the same check before a +// launch (POST /v1/agent-credentials/claude/verify). Checks are rate-limited per person and agent +// (agent_credentials.checked_at), passes are remembered (verified_at), and every keep or revoke is audited +// (agent_credential_audit). import type { AccountProvider } from './account-providers' import { markAgentCredentialRevoked, readUsableAgentCredential } from './agent-credentials' import type { Keyring } from './secrets-crypto' /** At most one auth check (and so one revoke) per person and agent per minute. */ export const CREDENTIAL_CHECK_INTERVAL_MS = 60_000 +/** A pass this recent answers verify without calling the provider. */ +export const CREDENTIAL_VERIFIED_FRESH_MS = 10 * 60_000 export type CredentialVerdict = 'valid' | 'invalid' | 'unknown' -export type UnauthorizedOutcome = 'revoked' | 'kept' | 'skipped' +export type CheckOutcome = 'revoked' | 'kept' | 'skipped' + +type CheckContext = { + db: D1Database + keyring: Keyring + provider: Pick + userId: string + now: number + fetch: typeof fetch +} async function audit( db: D1Database, - entry: { userId: string; agent: string; action: 'revoked' | 'kept'; reason: string; sandboxId: string; path: string; now: number } + entry: { userId: string; agent: string; action: 'revoked' | 'kept'; reason: string; sandboxId: string | null; path: string | null; now: number } ): Promise { await db .prepare( `INSERT INTO agent_credential_audit (user_id, agent, action, reason, sandbox_id, upstream_path, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)` ) - .bind(entry.userId, entry.agent, entry.action, entry.reason, entry.sandboxId, entry.path.split('?')[0]!.slice(0, 200), entry.now) + .bind(entry.userId, entry.agent, entry.action, entry.reason, entry.sandboxId, entry.path ? entry.path.split('?')[0]!.slice(0, 200) : null, entry.now) .run() - console.log(JSON.stringify({ event: `agent_credential_${entry.action}`, agent: entry.agent, by: 'egress_401', reason: entry.reason, sandboxId: entry.sandboxId })) + console.log(JSON.stringify({ event: `agent_credential_${entry.action}`, agent: entry.agent, reason: entry.reason, sandboxId: entry.sandboxId })) } -export async function handleAccountUnauthorized(ctx: { - db: D1Database - keyring: Keyring - provider: Pick - userId: string - sandboxId: string - /** The upstream path that answered 401 (audit only; no query string). */ - path: string - now: number - fetch: typeof fetch -}): Promise { +/** + * One rate-limited auth check. Revokes only on a definite auth failure; a pass is remembered. 'skipped' + * when another check ran within the minute or the credential isn't usable. + */ +async function checkCredential( + ctx: CheckContext, + trigger: { kind: 'egress_401'; sandboxId: string; path: string } | { kind: 'verify' } +): Promise { const { db, provider, userId, now } = ctx const agent = provider.agent - // Claim the check slot: a burst of parallel 401s, or a flapping provider, makes one check a minute. + // Claim the check slot: a burst of parallel 401s or verify calls makes one check a minute. const claimed = await db .prepare( `UPDATE agent_credentials SET checked_at = ? @@ -49,7 +59,7 @@ export async function handleAccountUnauthorized(ctx: { .bind(now, userId, agent, now - CREDENTIAL_CHECK_INTERVAL_MS) .run() if (!claimed.meta.changes) { - console.log(JSON.stringify({ event: 'agent_credential_401_skipped', agent, sandboxId: ctx.sandboxId })) + console.log(JSON.stringify({ event: 'agent_credential_check_skipped', agent, trigger: trigger.kind })) return 'skipped' } const real = await readUsableAgentCredential(db, ctx.keyring, userId, agent, now) @@ -57,12 +67,56 @@ export async function handleAccountUnauthorized(ctx: { return 'skipped' } const verdict: CredentialVerdict = provider.verify ? await provider.verify(real, ctx.fetch) : 'unknown' - const base = { userId, agent, sandboxId: ctx.sandboxId, path: ctx.path, now } + const where = + trigger.kind === 'egress_401' + ? { sandboxId: trigger.sandboxId, path: trigger.path } + : { sandboxId: null, path: null } + const base = { userId, agent, now, ...where } + if (verdict === 'valid') { + await db.prepare(`UPDATE agent_credentials SET verified_at = ? WHERE user_id = ? AND agent = ?`).bind(now, userId, agent).run() + } if (verdict !== 'invalid') { - await audit(db, { ...base, action: 'kept', reason: verdict === 'valid' ? 'check_passed' : 'check_inconclusive' }) + // A pass on a pre-launch verify is routine; a 401 that didn't hold up, or any inconclusive check, is audited. + if (trigger.kind === 'egress_401' || verdict === 'unknown') { + const reason = verdict === 'valid' ? 'check_passed' : 'check_inconclusive' + await audit(db, { ...base, action: 'kept', reason: trigger.kind === 'verify' ? `verify_${reason}` : reason }) + } return 'kept' } await markAgentCredentialRevoked(db, userId, agent, now) - await audit(db, { ...base, action: 'revoked', reason: 'provider_401_confirmed_by_check' }) + await audit(db, { + ...base, + action: 'revoked', + reason: trigger.kind === 'verify' ? 'verify_confirmed_auth_failure' : 'provider_401_confirmed_by_check' + }) return 'revoked' } + +export function handleAccountUnauthorized( + ctx: CheckContext & { sandboxId: string; path: string } +): Promise { + return checkCredential(ctx, { kind: 'egress_401', sandboxId: ctx.sandboxId, path: ctx.path }) +} + +/** + * Pre-launch verify: a pass within CREDENTIAL_VERIFIED_FRESH_MS answers at once; otherwise one check (rate + * limited). Returns what happened; the caller re-reads the state. + */ +export async function verifyAccountCredential( + ctx: CheckContext +): Promise<{ outcome: CheckOutcome | 'fresh'; verifiedAt: number | null }> { + const row = await ctx.db + .prepare(`SELECT verified_at FROM agent_credentials WHERE user_id = ? AND agent = ?`) + .bind(ctx.userId, ctx.provider.agent) + .first<{ verified_at: number | null }>() + const last = row?.verified_at ?? null + if (last !== null && ctx.now - last < CREDENTIAL_VERIFIED_FRESH_MS) { + return { outcome: 'fresh', verifiedAt: last } + } + const outcome = await checkCredential(ctx, { kind: 'verify' }) + const after = await ctx.db + .prepare(`SELECT verified_at FROM agent_credentials WHERE user_id = ? AND agent = ?`) + .bind(ctx.userId, ctx.provider.agent) + .first<{ verified_at: number | null }>() + return { outcome, verifiedAt: after?.verified_at ?? null } +} diff --git a/cloud/apps/sandbox-control/src/agent-credentials.ts b/cloud/apps/sandbox-control/src/agent-credentials.ts index 7a5b143d4e5..182369da3bf 100644 --- a/cloud/apps/sandbox-control/src/agent-credentials.ts +++ b/cloud/apps/sandbox-control/src/agent-credentials.ts @@ -1,6 +1,7 @@ // Account credentials for agents (agent-sources contract D11): one per person per agent, Personal only. // GET /v1/agent-credentials -> {claude, codex: {state, label?, expiresAt?}, providerEnabled, providerState} // PUT /v1/agent-credentials/claude {token, label?, expiresAt?} (flag S1; desktop main runs `claude setup-token`) +// POST /v1/agent-credentials/claude/verify -> {claude, verifiedAt, checked} (pre-launch check, agent-credential-checks.ts) // DELETE /v1/agent-credentials/:agent // Values are never returned or logged. They leave the Worker only when the egress proxy swaps them into a // request from the person's own, unshared workspace (D10, D13). The Codex broker (flag S2) stores its tokens @@ -104,7 +105,8 @@ export async function putAgentCredential( VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'active', ?, ?) ON CONFLICT (user_id, agent) DO UPDATE SET account_id = excluded.account_id, kek_id = excluded.kek_id, wrapped_dek = excluded.wrapped_dek, ciphertext = excluded.ciphertext, label = excluded.label, - expires_at = excluded.expires_at, state = 'active', updated_at = excluded.updated_at` + expires_at = excluded.expires_at, state = 'active', updated_at = excluded.updated_at, + checked_at = NULL, verified_at = NULL` ) .bind(input.userId, input.accountId, input.agent, sealed.kekId, sealed.wrappedDek, sealed.ciphertext, input.label ?? null, input.expiresAt ?? null, now, now) .run() diff --git a/cloud/apps/sandbox-control/src/api/attachments.ts b/cloud/apps/sandbox-control/src/api/attachments.ts new file mode 100644 index 00000000000..233555d2c84 --- /dev/null +++ b/cloud/apps/sandbox-control/src/api/attachments.ts @@ -0,0 +1,164 @@ +// Files for an agent to read (POST /v1/workspaces/:id/attachments, MCP upload_attachment). The +// bytes go straight onto the workspace's own disk through the provider's files API, outside the +// repo so they never show up in git status; D1 keeps only the metadata a message references. +import { z } from 'zod' +import { ApiError } from './caller' +import { randomId } from './keys' + +export const ATTACHMENTS_ROOT = '/vercel/sandbox/attachments' +/** Raw uploads (curl --data-binary). Workers buffer the body, so this stays well under memory. */ +export const MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024 +/** JSON uploads carry base64 (MCP tool calls): the MCP request cap bounds them. */ +export const MAX_JSON_ATTACHMENT_BYTES = 5 * 1024 * 1024 +export const MAX_ATTACHMENTS_PER_MESSAGE = 10 + +export type AttachmentRow = { + id: string + sandbox_id: string + account_id: string + uploaded_by: string + filename: string + content_type: string + byte_size: number + path: string + created_at: number +} + +export function attachmentView(row: AttachmentRow) { + return { + id: row.id, + workspaceId: row.sandbox_id, + filename: row.filename, + contentType: row.content_type, + byteSize: row.byte_size, + path: row.path, + createdAt: row.created_at + } +} + +/** A name safe for one path segment: ASCII letters, digits, `._-` and spaces; never hidden, never empty. */ +export function safeFilename(raw: string): string { + const base = raw.split(/[\\/]/).at(-1) ?? '' + const cleaned = base + .normalize('NFKD') + .replace(/[\u0300-\u036f]/g, '') + .replace(/[^A-Za-z0-9._ -]/g, '_') + .replace(/^[.\s]+/, '') + .trim() + const capped = cleaned.length > 100 ? `${cleaned.slice(0, 80)}${cleaned.slice(cleaned.lastIndexOf('.')).slice(0, 20)}` : cleaned + return capped || 'file' +} + +const ContentType = z.string().trim().min(3).max(127).regex(/^[\w.+-]+\/[\w.+-]+$/) + +const JsonUpload = z + .object({ + filename: z.string().min(1).max(255), + contentType: ContentType.optional(), + /** Base64 (standard or url-safe) file bytes. */ + data: z.string().min(1).max(Math.ceil((MAX_JSON_ATTACHMENT_BYTES * 4) / 3) + 4) + }) + .strict() + +function decodeBase64(data: string): Uint8Array { + const normal = data.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, '') + if (!/^[A-Za-z0-9+/]*={0,2}$/.test(normal)) { + throw new ApiError(400, 'invalid_request', 'data: not base64') + } + const binary = atob(normal) + const bytes = new Uint8Array(binary.length) + for (let i = 0; i < binary.length; i++) { + bytes[i] = binary.charCodeAt(i) + } + return bytes +} + +/** + * Reads an upload: JSON `{filename, contentType?, data}` (base64), or the raw bytes with + * `?filename=` and the file's own Content-Type. + */ +export async function readUpload(request: Request, url: URL): Promise<{ filename: string; contentType: string; bytes: Uint8Array }> { + const declared = (request.headers.get('content-type') ?? '').split(';')[0]!.trim().toLowerCase() + const length = Number(request.headers.get('content-length') ?? NaN) + if (declared === 'application/json') { + if (length > MAX_JSON_ATTACHMENT_BYTES * 1.4) { + throw new ApiError(413, 'too_large', `max ${MAX_JSON_ATTACHMENT_BYTES} bytes as JSON; upload larger files raw`) + } + const parsed = JsonUpload.safeParse(JSON.parse(await request.text())) + if (!parsed.success) { + const issue = parsed.error.issues[0] + throw new ApiError(400, 'invalid_request', issue ? `${issue.path.join('.') || 'body'}: ${issue.message}` : undefined) + } + const bytes = decodeBase64(parsed.data.data) + if (bytes.length > MAX_JSON_ATTACHMENT_BYTES) { + throw new ApiError(413, 'too_large', `max ${MAX_JSON_ATTACHMENT_BYTES} bytes as JSON; upload larger files raw`) + } + return { filename: parsed.data.filename, contentType: parsed.data.contentType ?? 'application/octet-stream', bytes } + } + const filename = url.searchParams.get('filename') + if (!filename || filename.length > 255) { + throw new ApiError(400, 'invalid_request', 'filename: required query parameter for raw uploads') + } + if (length > MAX_ATTACHMENT_BYTES) { + throw new ApiError(413, 'too_large', `max ${MAX_ATTACHMENT_BYTES} bytes`) + } + const bytes = new Uint8Array(await request.arrayBuffer()) + if (bytes.length > MAX_ATTACHMENT_BYTES) { + throw new ApiError(413, 'too_large', `max ${MAX_ATTACHMENT_BYTES} bytes`) + } + const contentType = ContentType.safeParse(declared) + return { filename, contentType: contentType.success ? contentType.data : 'application/octet-stream', bytes } +} + +export function newAttachment(input: { sandboxId: string; accountId: string; uploadedBy: string; filename: string; contentType: string; byteSize: number }, now: number): AttachmentRow { + const id = randomId('att') + const filename = safeFilename(input.filename) + return { + id, + sandbox_id: input.sandboxId, + account_id: input.accountId, + uploaded_by: input.uploadedBy, + filename, + content_type: input.contentType, + byte_size: input.byteSize, + path: `${ATTACHMENTS_ROOT}/${id}/${filename}`, + created_at: now + } +} + +export async function insertAttachment(db: D1Database, row: AttachmentRow): Promise { + await db + .prepare( + `INSERT INTO workspace_attachments (id, sandbox_id, account_id, uploaded_by, filename, content_type, byte_size, path, created_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)` + ) + .bind(row.id, row.sandbox_id, row.account_id, row.uploaded_by, row.filename, row.content_type, row.byte_size, row.path, row.created_at) + .run() +} + +/** The named attachments of this workspace, in the order given; 400 if any is unknown or elsewhere. */ +export async function resolveAttachments(db: D1Database, sandboxId: string, ids: readonly string[]): Promise { + if (ids.length === 0) { + return [] + } + const unique = [...new Set(ids)] + const { results } = await db + .prepare(`SELECT * FROM workspace_attachments WHERE sandbox_id = ? AND id IN (${unique.map(() => '?').join(', ')})`) + .bind(sandboxId, ...unique) + .all() + const byId = new Map(results.map((row) => [row.id, row])) + const missing = unique.filter((id) => !byId.has(id)) + if (missing.length > 0) { + throw new ApiError(400, 'invalid_request', `attachments: unknown in this workspace: ${missing.join(',').slice(0, 200)}`) + } + return unique.map((id) => byId.get(id)!) +} + +/** The message text an agent gets: the user's words, then where each attached file is on disk. */ +export function withAttachmentPaths(text: string, attachments: readonly AttachmentRow[]): string { + if (attachments.length === 0) { + return text + } + const lines = attachments.map((row) => `- ${row.path} (${row.content_type}, ${row.byte_size} bytes)`) + return `${text}\n\nAttached files (read them from disk):\n${lines.join('\n')}` +} diff --git a/cloud/apps/sandbox-control/src/api/messages.ts b/cloud/apps/sandbox-control/src/api/messages.ts index bed03311306..77df1da52c7 100644 --- a/cloud/apps/sandbox-control/src/api/messages.ts +++ b/cloud/apps/sandbox-control/src/api/messages.ts @@ -109,6 +109,18 @@ async function settle( .run() } +/** + * What the agent is typed: a teammate's message names its sender (W4: agents address them and + * commit as them via `orca-git-as`); nobody can type a leading envelope to impersonate someone else. + */ +export async function agentText(db: D1Database, workspace: { user_id: string; account_id: string }, sentBy: string, body: string): Promise { + if (sentBy === workspace.user_id) { + return parseSenderEnvelope(body).body + } + const name = (await memberNamesFor(db, workspace.account_id, [sentBy])).get(sentBy) ?? sentBy + return withSenderEnvelope(body, { userId: sentBy, name }) +} + /** * Delivers one queued message: wakes the workspace if needed, then continues the named session or * starts a new agent session with the text as its first prompt. @@ -127,15 +139,7 @@ export async function deliverMessage(life: LifecycleDeps, message: MessageRow): row = (await resumeSandbox(life, row)).row } const sessionId = row.session_id! - // A teammate's message names its sender (W4: agents address them and commit as them via - // `orca-git-as`); nobody can type a leading envelope to impersonate someone else. - const text = - message.sent_by === row.user_id - ? parseSenderEnvelope(message.body).body - : withSenderEnvelope(message.body, { - userId: message.sent_by, - name: (await memberNamesFor(life.db, message.account_id, [message.sent_by])).get(message.sent_by) ?? message.sent_by - }) + const text = await agentText(life.db, row, message.sent_by, message.body) let handle: string if (message.session_handle) { await sendToSession(life.provider, sessionId, message.session_handle, text) diff --git a/cloud/apps/sandbox-control/src/api/models.ts b/cloud/apps/sandbox-control/src/api/models.ts new file mode 100644 index 00000000000..7202e9c98cc --- /dev/null +++ b/cloud/apps/sandbox-control/src/api/models.ts @@ -0,0 +1,77 @@ +// GET /v1/models (MCP list_models): the agents a cloud workspace runs and the models/efforts each +// accepts. Built from the same seed catalogs the desktop's model picker uses, so the two never +// disagree; the VM's own CLI may know newer models, which session create also accepts. +import { + CLAUDE_SESSION_OPTION_CATALOG, + CODEX_SESSION_OPTION_CATALOG +} from '../../../../../src/shared/agent-session/options/agent-session-option-catalog-claude-codex' +import { + CURSOR_SESSION_OPTION_CATALOG, + GEMINI_SESSION_OPTION_CATALOG +} from '../../../../../src/shared/agent-session/options/agent-session-option-catalog-gemini-cursor' +import { OPENCODE_LAUNCH_OPTION_CATALOG } from '../../../../../src/shared/agent-session/options/agent-session-option-catalog-opencode' +import type { AgentSessionOptionCatalog, CatalogModel } from '../../../../../src/shared/agent-session/options/agent-session-option-catalog-types' +import { AGENTS, type AgentId } from './vm-agent' + +const LABELS: Record = { + claude: 'Claude Code', + codex: 'Codex', + opencode: 'OpenCode', + gemini: 'Gemini CLI', + cursor: 'Cursor', + copilot: 'GitHub Copilot' +} + +const CATALOGS: Partial> = { + claude: CLAUDE_SESSION_OPTION_CATALOG, + codex: CODEX_SESSION_OPTION_CATALOG, + gemini: GEMINI_SESSION_OPTION_CATALOG, + cursor: CURSOR_SESSION_OPTION_CATALOG, + opencode: OPENCODE_LAUNCH_OPTION_CATALOG +} + +/** Model ids travel as one argv entry (`--model=`); this keeps them to what agent CLIs use. */ +export const MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:/@[\]-]{0,127}$/ +export const EFFORT_ID = /^[a-z]{2,16}$/ + +function modelView(model: CatalogModel) { + const effort = model.options.find((option) => option.id === 'effort') + const efforts = effort?.kind.type === 'select' ? effort.kind.choices.map((choice) => String(choice.value)) : [] + return { + id: model.id, + label: model.label, + description: model.description ?? null, + default: model.isDefault === true, + efforts, + defaultEffort: effort?.kind.type === 'select' ? effort.kind.defaultValue : null, + fastMode: model.options.some((option) => option.id === 'fastMode' || option.id === 'serviceTier') + } +} + +export type ModelsView = ReturnType + +export function modelsView() { + return { + agents: AGENTS.map((agent) => { + const models = (CATALOGS[agent]?.models ?? []).map(modelView) + return { + id: agent, + label: LABELS[agent], + default: agent === 'claude', + // Null: the agent's own default (its CLI picks; nothing is passed). + defaultModel: models.find((model) => model.default)?.id ?? null, + models + } + }) + } +} + +/** The efforts the catalog lists for this agent's model, or null when it lists none (any is passed through). */ +export function knownEfforts(agent: AgentId, model: string): string[] | null { + const found = CATALOGS[agent]?.models.find((candidate) => candidate.id === model) + if (!found) { + return null + } + const efforts = modelView(found).efforts + return efforts.length > 0 ? efforts : [] +} diff --git a/cloud/apps/sandbox-control/src/api/openapi.ts b/cloud/apps/sandbox-control/src/api/openapi.ts index f18428d2ea7..7f3514003b4 100644 --- a/cloud/apps/sandbox-control/src/api/openapi.ts +++ b/cloud/apps/sandbox-control/src/api/openapi.ts @@ -99,6 +99,53 @@ const schemas: Record = { preview: { type: ['string', 'null'], description: 'Last few lines of the session' } } }, + NewSession: { + type: 'object', + properties: { + handle: { type: 'string', description: 'Session handle (term_…): pass as `session` to send_message' }, + workspaceId: { type: 'string' }, + agent: { type: 'string', enum: [...AGENTS] }, + model: { type: ['string', 'null'] }, + effort: { type: ['string', 'null'] }, + name: { type: ['string', 'null'] } + } + }, + Attachment: { + type: 'object', + properties: { + id: { type: 'string', description: 'att_… — pass in a message\'s `attachments`' }, + workspaceId: { type: 'string' }, + filename: { type: 'string', description: 'Sanitized file name' }, + contentType: { type: 'string' }, + byteSize: { type: 'integer' }, + path: { type: 'string', description: 'Where the file is on the workspace disk (outside the repo)' }, + createdAt: { type: 'integer' } + } + }, + AgentModels: { + type: 'object', + properties: { + id: { type: 'string', enum: [...AGENTS] }, + label: { type: 'string' }, + default: { type: 'boolean', description: 'The agent used when none is given' }, + defaultModel: { type: ['string', 'null'], description: "Null: the agent CLI's own default" }, + models: { + type: 'array', + items: { + type: 'object', + properties: { + id: { type: 'string' }, + label: { type: 'string' }, + description: { type: ['string', 'null'] }, + default: { type: 'boolean' }, + efforts: { type: 'array', items: { type: 'string' }, description: 'Values for `effort`; empty when the model takes none' }, + defaultEffort: { type: ['string', 'null'] }, + fastMode: { type: 'boolean' } + } + } + } + } + }, Routine: { type: 'object', properties: { @@ -213,6 +260,14 @@ export const OPERATIONS: Record> = { '/v1/me': { get: { tags: ['Account'], summary: 'Who the token acts as', responses: { 200: { description: 'Caller', schema: obj({ accountId: { type: 'string' }, userId: { type: 'string' }, role: { type: 'string' }, scopes: { type: 'array', items: { type: 'string' } } }) } } } }, + '/v1/models': { + get: { + tags: ['Agents'], + summary: 'Agents and models a session can run', + description: 'Every agent CLI a cloud workspace ships, with the models, effort levels, defaults and fast-mode support the model picker knows. Pass `agent`, `model` and `effort` when creating a session. A model id newer than this list is passed to the agent CLI as is.', + responses: { 200: { description: 'Agents', schema: obj({ agents: { type: 'array', items: ref('AgentModels') } }) } } + } + }, '/v1/api-keys': { get: { tags: ['API keys'], sessionOnly: true, summary: 'List Orca API keys', description: 'Owners and admins see every key on the team; members see their own.', responses: { 200: { description: 'Keys', schema: list('keys', 'ApiKey') } } }, post: { @@ -341,6 +396,39 @@ export const OPERATIONS: Record> = { '/v1/workspaces/{id}/archive': { post: { tags: ['Workspaces'], scope: 'workspaces:write', summary: 'Archive: sleep and hide from default lists', params: [WS], responses: { 200: { description: 'Archived', schema: one('workspace', 'Workspace') } } } }, + '/v1/workspaces/{id}/unarchive': { + post: { + tags: ['Workspaces'], + scope: 'workspaces:write', + summary: 'Unarchive: back in default lists and running again', + description: 'Owner only. Idempotent: a workspace that is not archived is returned unchanged.', + params: [WS], + responses: { 200: { description: 'Running', schema: one('workspace', 'Workspace') } } + } + }, + '/v1/workspaces/{id}/rename': { + post: { + tags: ['Workspaces'], + scope: 'workspaces:write', + summary: 'Rename a workspace', + description: 'Changes the display name everywhere (desktop Home, phone, API). The git branch is not renamed.', + params: [WS], + body: obj({ name: { type: 'string', minLength: 1, maxLength: 100 } }, ['name']), + responses: { 200: { description: 'Renamed', schema: one('workspace', 'Workspace') } } + } + }, + '/v1/workspaces/{id}/attachments': { + post: { + tags: ['Agents'], + scope: 'messages:write', + summary: 'Upload a file for an agent', + description: + 'Puts a file on the workspace disk (outside the repo) and returns its id; pass up to 10 ids as `attachments` when sending a message or creating a session, and the agent is told where each file is. Send the raw bytes (`--data-binary @file`, the file\'s Content-Type, `?filename=`; up to 25 MB) or JSON `{filename, contentType, data}` with base64 data (up to 5 MB, what MCP clients use). A sleeping workspace is woken first.', + params: [WS, { name: 'filename', in: 'query', description: 'File name, for raw uploads', schema: { type: 'string' } }], + body: obj({ filename: { type: 'string' }, contentType: { type: 'string' }, data: { type: 'string', contentEncoding: 'base64' } }, ['filename', 'data']), + responses: { 201: { description: 'Uploaded', schema: one('attachment', 'Attachment') }, 413: 'File too large' } + } + }, '/v1/workspaces/{id}/messages': { get: { tags: ['Agents'], scope: 'workspaces:read', summary: 'Recent messages sent to this workspace', params: [WS], responses: { 200: { description: 'Messages', schema: list('messages', 'Message') } } }, post: { @@ -349,7 +437,15 @@ export const OPERATIONS: Record> = { summary: 'Send a message to an agent', description: 'Queues the message and returns 202 at once. A sleeping workspace is woken first. Without `session` a new agent session starts with the text as its prompt; with `session` the text is typed into that session. Poll the message for `delivered`.', params: [WS], - body: obj({ text: { type: 'string', maxLength: 32000 }, agent: { type: 'string', enum: [...AGENTS] }, session: { type: 'string' } }, ['text']), + body: obj( + { + text: { type: 'string', maxLength: 32000 }, + agent: { type: 'string', enum: [...AGENTS] }, + session: { type: 'string' }, + attachments: { type: 'array', maxItems: 10, items: { type: 'string' }, description: 'Attachment ids from POST /attachments' } + }, + ['text'] + ), responses: { 202: { description: 'Queued', schema: one('message', 'Message') } } } }, @@ -357,7 +453,50 @@ export const OPERATIONS: Record> = { get: { tags: ['Agents'], scope: 'workspaces:read', summary: 'Delivery status of a message', params: [WS, idParam('messageId', 'Message id')], responses: { 200: { description: 'Message', schema: one('message', 'Message') } } } }, '/v1/workspaces/{id}/sessions': { - get: { tags: ['Agents'], scope: 'workspaces:read', summary: 'Agent sessions in a running workspace', params: [WS], responses: { 200: { description: 'Sessions (empty while sleeping)', schema: obj({ workspaceStatus: { type: 'string' }, sessions: { type: 'array', items: ref('Session') } }) } } } + get: { tags: ['Agents'], scope: 'workspaces:read', summary: 'Agent sessions in a running workspace', params: [WS], responses: { 200: { description: 'Sessions (empty while sleeping)', schema: obj({ workspaceStatus: { type: 'string' }, sessions: { type: 'array', items: ref('Session') } }) } } }, + post: { + tags: ['Agents'], + scope: 'messages:write', + summary: 'Start a new agent session (a new chat)', + description: + 'Starts another agent session in the workspace, waking it first if it sleeps, and returns its handle once the agent is up. Optional: `model` and `effort` (see GET /v1/models; a known model with an effort it does not take answers 400), `name`, and a first `message` with `attachments`. Without `message` the agent waits for send_message.', + params: [WS], + body: obj({ + agent: { type: 'string', enum: [...AGENTS], default: 'claude' }, + model: { type: 'string' }, + effort: { type: 'string', description: 'Requires model' }, + name: { type: 'string', maxLength: 100 }, + message: { type: 'string', maxLength: 32000 }, + attachments: { type: 'array', maxItems: 10, items: { type: 'string' }, description: 'Requires message' } + }), + responses: { 201: { description: 'Started', schema: one('session', 'NewSession') } } + } + }, + '/v1/workspaces/{id}/sessions/{handle}/cancel': { + post: { + tags: ['Agents'], + scope: 'messages:write', + summary: "Stop the agent's current turn", + description: "Interrupts the running turn (an Escape, as a person would press) and drops this session's queued messages. Nothing is interrupted while the workspace sleeps; queued messages are still dropped.", + params: [WS, idParam('handle', 'Session handle (term_…)')], + responses: { + 200: { + description: 'Canceled', + schema: obj({ workspaceId: { type: 'string' }, session: { type: 'string' }, interrupted: { type: 'boolean' }, canceledQueuedMessages: { type: 'integer' } }) + } + } + } + }, + '/v1/workspaces/{id}/sessions/{handle}/rename': { + post: { + tags: ['Agents'], + scope: 'messages:write', + summary: 'Rename an agent session', + description: 'Sets the session (tab) title the desktop and phone show. 409 while the workspace sleeps.', + params: [WS, idParam('handle', 'Session handle (term_…)')], + body: obj({ name: { type: 'string', minLength: 1, maxLength: 100 } }, ['name']), + responses: { 200: { description: 'Renamed', schema: obj({ session: obj({ handle: { type: 'string' }, workspaceId: { type: 'string' }, name: { type: 'string' } }) }) } } + } }, '/v1/workspaces/{id}/sessions/{handle}': { get: { @@ -503,7 +642,15 @@ curl -X DELETE ${o}/v1/workspaces/$ID -H "Authorization: Bearer $ORCA_API_

Point any MCP client at ${o}/mcp (Streamable HTTP). Clients that support OAuth register themselves and open an approval page in the browser: approve with a one-time code from Orca → Settings → Orca API keys → Approve an app, or with one of your API keys. The app never gets more than that key may do. Clients without OAuth can send an API key as a bearer token.

claude mcp add --transport http orca-cloud ${o}/mcp
 claude mcp add --transport http orca-cloud ${o}/mcp --header "Authorization: Bearer $ORCA_API_KEY"
-

Tools: whoami, list_projects, list_workspaces, get_workspace, create_workspace, sleep_workspace, wake_workspace, archive_workspace, destroy_workspace, send_message, get_message, list_sessions, read_session, list_routines, run_routine. They use the same scopes, rate limits and audit log as the REST API.

+

Tools: whoami, list_models, list_projects, list_workspaces, get_workspace, create_workspace, rename_workspace, sleep_workspace, wake_workspace, archive_workspace, unarchive_workspace, destroy_workspace, create_session, list_sessions, read_session, rename_session, cancel_session, upload_attachment, send_message, get_message, list_routines, run_routine. They use the same scopes, rate limits and audit log as the REST API.

+

There is no SQL search over transcripts. Chats are end-to-end encrypted on the workspace's own disk, so the control plane cannot read them to index. Use read_session to see what an agent did.

+

New chat, files, stop

+
curl -s ${o}/v1/models -H "Authorization: Bearer $ORCA_API_KEY"
+curl -s ${o}/v1/workspaces/$ID/attachments?filename=bug.png -H "Authorization: Bearer $ORCA_API_KEY" \\
+  -H 'content-type: image/png' --data-binary @bug.png
+curl -s ${o}/v1/workspaces/$ID/sessions -H "Authorization: Bearer $ORCA_API_KEY" -H 'content-type: application/json' \\
+  -d '{"agent":"codex","model":"gpt-5.5","effort":"high","message":"Fix what the screenshot shows","attachments":["att_…"]}'
+curl -X POST ${o}/v1/workspaces/$ID/sessions/$HANDLE/cancel -H "Authorization: Bearer $ORCA_API_KEY"

Limits and errors

Rate limits120 requests/min per key, 30 messages/min per user, 10 workspace creates/min per team. 429 responses carry Retry-After.
diff --git a/cloud/apps/sandbox-control/src/api/router.ts b/cloud/apps/sandbox-control/src/api/router.ts index ba59b0dc4ab..cdc1c9eff21 100644 --- a/cloud/apps/sandbox-control/src/api/router.ts +++ b/cloud/apps/sandbox-control/src/api/router.ts @@ -12,9 +12,20 @@ import { allowed, authorize, canSee, isOrgAdmin, isWorkspaceOwner } from './acce import { ApiError, actorOf, authenticateApi, isAdmin, requireAdmin, requireScope, scopesForRole, type ApiCaller } from './caller' import { auditCaller, auditView, consumeRate, listAudit, rateHeaders, RateLimitedError, type RateLimit } from './audit' import { API_SCOPES, ADMIN_SCOPES, apiKeyView, getApiKey, listApiKeys, mintApiKey, revokeApiKey, type ApiScope } from './keys' -import { deliverMessage, getMessage, listMessages, MAX_MESSAGE_CHARS, messageView, queueMessage } from './messages' +import { agentText, deliverMessage, getMessage, listMessages, MAX_MESSAGE_CHARS, messageView, queueMessage } from './messages' import { getAccountSettings, putAccountSettings } from './settings' -import { listSessions, readSession, VmAgentError } from './vm-agent' +import { interruptSession, launchAgent, listSessions, readSession, renameSession, VmAgentError } from './vm-agent' +import { + attachmentView, + insertAttachment, + MAX_ATTACHMENTS_PER_MESSAGE, + newAttachment, + readUpload, + resolveAttachments, + withAttachmentPaths +} from './attachments' +import { EFFORT_ID, knownEfforts, MODEL_ID, modelsView } from './models' +import { resumeSandbox } from '../lifecycle' import { archiveProject, archiveWorkspace, @@ -85,14 +96,32 @@ const CreateWorkspaceBody = z message: z.object({ text: z.string().min(1).max(MAX_MESSAGE_CHARS), agent: z.enum(AGENTS).optional() }).strict().optional() }) .strict() +const SessionHandle = z.string().regex(/^term_[A-Za-z0-9-]{1,80}$/) +const AttachmentIds = z.array(z.string().regex(/^att_[A-Za-z0-9]{1,64}$/)).min(1).max(MAX_ATTACHMENTS_PER_MESSAGE) const MessageBody = z .object({ text: z.string().min(1).max(MAX_MESSAGE_CHARS), agent: z.enum(AGENTS).optional(), /** A session handle from GET /sessions or a previous message: continue that conversation. */ - session: z.string().regex(/^term_[A-Za-z0-9-]{1,80}$/).optional() + session: SessionHandle.optional(), + /** Files uploaded with POST /attachments: their on-disk paths are appended for the agent. */ + attachments: AttachmentIds.optional() }) .strict() +const CreateSessionBody = z + .object({ + agent: z.enum(AGENTS).optional(), + model: z.string().regex(MODEL_ID, 'a model id from GET /v1/models').optional(), + effort: z.string().regex(EFFORT_ID).optional(), + name: Name.optional(), + /** Optional first prompt; without it the agent starts idle and waits for send_message. */ + message: z.string().min(1).max(MAX_MESSAGE_CHARS).optional(), + attachments: AttachmentIds.optional() + }) + .strict() + .refine((body) => !body.effort || body.model, { message: 'effort requires model', path: ['effort'] }) + .refine((body) => !body.attachments || body.message, { message: 'attachments require message', path: ['attachments'] }) +const RenameBody = z.object({ name: Name }).strict() function json(body: unknown, status = 200, headers: Record = {}): Response { return Response.json(body, { status, headers: { 'cache-control': 'no-store', ...headers } }) @@ -152,7 +181,7 @@ import { parseWakeWait } from '../wire' import { MachineSizeInput } from '../machine-size' export function isApiPath(pathname: string): boolean { - return /^\/v1\/(me|api-keys|settings|audit|projects|workspaces|routines|oauth-approvals|oauth-grants)(\/|$)/.test(pathname) + return /^\/v1\/(me|models|api-keys|settings|audit|projects|workspaces|routines|oauth-approvals|oauth-grants)(\/|$)/.test(pathname) } export async function handleApi(request: Request, url: URL, env: Parameters[0], ctx: ApiContext): Promise { @@ -243,6 +272,11 @@ async function route(request: Request, url: URL, caller: ApiCaller, ctx: ApiCont }) } + if (resource === 'models' && !id && method === 'GET') { + // Static catalog, no account data: any authenticated caller may read it. + return json(modelsView()) + } + if (resource === 'api-keys') { if (caller.via !== 'session') { // Keys are made and revoked by a signed-in person, never by another key. @@ -435,7 +469,7 @@ async function route(request: Request, url: URL, caller: ApiCaller, ctx: ApiCont const life = () => requireLife(ctx) const mutate = async (action: string, run: () => Promise) => { requireScope(caller, 'workspaces:write') - authorize(caller, row, action === 'wake' ? 'owner' : 'manage') + authorize(caller, row, action === 'wake' || action === 'unarchive' ? 'owner' : 'manage') if (caller.via === 'workspace' && row.id === caller.sandboxId) { // An agent must not put its own VM to sleep or delete it from under itself. throw new ApiError(403, 'forbidden', 'own_workspace') @@ -477,6 +511,117 @@ async function route(request: Request, url: URL, caller: ApiCaller, ctx: ApiCont if (sub === 'archive' && method === 'POST') { return mutate('archive', () => archiveWorkspace(life(), row)) } + if (sub === 'unarchive' && method === 'POST') { + if (row.status !== 'archived' && row.archived_at === null) { + // Idempotent: a retry after success (or a never-archived workspace) is not an error. + requireScope(caller, 'workspaces:write') + authorize(caller, row, 'owner') + return json({ workspace: workspaceView(row) }) + } + // Back in default lists and running again (same path as waking an archived workspace). + return mutate('unarchive', () => wakeWorkspace(life(), row)) + } + if (sub === 'rename' && method === 'POST') { + requireScope(caller, 'workspaces:write') + authorize(caller, row, 'manage') + const body = parse(RenameBody, await ctx.readJson()) + await ctx.db.prepare('UPDATE sandboxes SET name = ? WHERE id = ?').bind(body.name, row.id).run() + await auditCaller(ctx.db, caller, { action: 'workspace.rename', targetType: 'workspace', targetId: row.id, detail: { chars: body.name.length } }, now) + return json({ workspace: workspaceView({ ...row, name: body.name }) }) + } + // The agent's VM, woken if it sleeps (sessions and files need a running sandbox). + const runningSession = async (): Promise => { + if (row.status === 'archived' || row.archived_at !== null) { + throw new ApiError(409, 'conflict', 'workspace_archived') + } + if (row.status === 'running' && row.session_id) { + return row.session_id + } + const ready = await resumeSandbox(life(), row) + return ready.row.session_id! + } + if (sub === 'sessions' && !subId && method === 'POST') { + // A new chat: start another agent session in this workspace (optionally with a first prompt). + requireScope(caller, 'messages:write') + authorize(caller, row, 'open') + const body = parse(CreateSessionBody, await ctx.readJson()) + const agent = body.agent ?? 'claude' + if (body.model && body.effort) { + const efforts = knownEfforts(agent, body.model) + if (efforts && !efforts.includes(body.effort)) { + throw new ApiError(400, 'invalid_request', `effort: ${body.model} takes ${efforts.length ? efforts.join(', ') : 'no effort'}`) + } + } + if (body.message) { + await consumeRate(ctx.db, messageBucket(caller), MESSAGES_PER_MINUTE, now) + } + const attachments = await resolveAttachments(ctx.db, row.id, body.attachments ?? []) + const started = performance.now() + const sessionId = await runningSession() + // A teammate's first prompt names its sender, exactly like a message (deliverMessage). + const prompt = body.message ? await agentText(ctx.db, row, caller.userId, withAttachmentPaths(body.message, attachments)) : null + const handle = await launchAgent(life().provider, sessionId, agent, prompt, { model: body.model, effort: body.effort }) + if (body.name) { + await renameSession(life().provider, sessionId, handle, body.name) + } + await auditCaller( + ctx.db, + caller, + { action: 'workspace.session.create', targetType: 'workspace', targetId: row.id, detail: { handle, agent, model: body.model ?? null, prompt: Boolean(prompt), attachments: attachments.length, ms: Math.round(performance.now() - started) } }, + ctx.now() + ) + return json({ session: { handle, workspaceId: row.id, agent, model: body.model ?? null, effort: body.effort ?? null, name: body.name ?? null } }, 201) + } + if (sub === 'sessions' && subId && parts[4] && method === 'POST') { + requireScope(caller, 'messages:write') + authorize(caller, row, 'open') + if (!SessionHandle.safeParse(subId).success) { + throw new ApiError(404, 'not_found') + } + if (parts[4] === 'cancel' && !parts[5]) { + // Queued messages for this session never get typed; the running turn gets an interrupt. + const dropped = await ctx.db + .prepare(`UPDATE workspace_messages SET status = 'failed', error = 'canceled', updated_at = ? WHERE sandbox_id = ? AND session_handle = ? AND status = 'queued'`) + .bind(now, row.id, subId) + .run() + const running = row.status === 'running' && row.session_id !== null + if (running) { + await interruptSession(life().provider, row.session_id!, subId) + } + const canceledQueuedMessages = dropped.meta.changes ?? 0 + await auditCaller(ctx.db, caller, { action: 'workspace.session.cancel', targetType: 'workspace', targetId: row.id, detail: { handle: subId, interrupted: running, canceledQueuedMessages } }, ctx.now()) + return json({ workspaceId: row.id, session: subId, interrupted: running, canceledQueuedMessages }) + } + if (parts[4] === 'rename' && !parts[5]) { + const body = parse(RenameBody, await ctx.readJson()) + if (row.status !== 'running' || !row.session_id) { + throw new ApiError(409, 'conflict', 'workspace_not_running') + } + await renameSession(life().provider, row.session_id, subId, body.name) + await auditCaller(ctx.db, caller, { action: 'workspace.session.rename', targetType: 'workspace', targetId: row.id, detail: { handle: subId } }, ctx.now()) + return json({ session: { handle: subId, workspaceId: row.id, name: body.name } }) + } + } + if (sub === 'attachments' && !subId && method === 'POST') { + requireScope(caller, 'messages:write') + authorize(caller, row, 'open') + const provider = life().provider + if (!provider.writeFile) { + throw new ApiError(503, 'not_configured') + } + await consumeRate(ctx.db, messageBucket(caller), MESSAGES_PER_MINUTE, now) + const upload = await readUpload(request, url) + const sessionId = await runningSession() + const attachment = newAttachment( + { sandboxId: row.id, accountId: row.account_id, uploadedBy: caller.userId, filename: upload.filename, contentType: upload.contentType, byteSize: upload.bytes.length }, + now + ) + const started = performance.now() + await provider.writeFile(sessionId, attachment.path, upload.bytes) + await insertAttachment(ctx.db, attachment) + await auditCaller(ctx.db, caller, { action: 'workspace.attachment', targetType: 'workspace', targetId: row.id, detail: { attachmentId: attachment.id, bytes: attachment.byte_size, ms: Math.round(performance.now() - started) } }, ctx.now()) + return json({ attachment: attachmentView(attachment) }, 201) + } if (sub === 'sessions' && !subId && method === 'GET') { requireScope(caller, 'workspaces:read') authorize(caller, row, 'open') @@ -485,7 +630,7 @@ async function route(request: Request, url: URL, caller: ApiCaller, ctx: ApiCont } return json({ workspaceStatus: 'running', sessions: await listSessions(life().provider, row.session_id) }) } - if (sub === 'sessions' && subId && method === 'GET') { + if (sub === 'sessions' && subId && !parts[4] && method === 'GET') { requireScope(caller, 'workspaces:read') authorize(caller, row, 'owner') if (!/^term_[A-Za-z0-9-]{1,80}$/.test(subId)) { @@ -518,8 +663,10 @@ async function route(request: Request, url: URL, caller: ApiCaller, ctx: ApiCont const life = requireLife(ctx) await consumeRate(ctx.db, messageBucket(caller), MESSAGES_PER_MINUTE, now) const body = parse(MessageBody, await ctx.readJson()) - const queued = await queueMessage(ctx.db, { workspace: row, sentBy: caller.userId, agent: body.agent ?? 'claude', text: body.text, session: body.session }, now) - await auditCaller(ctx.db, caller, { action: 'workspace.message', targetType: 'workspace', targetId: row.id, detail: { messageId: queued.id, chars: body.text.length, continues: Boolean(body.session) } }, now) + const attachments = await resolveAttachments(ctx.db, row.id, body.attachments ?? []) + const text = withAttachmentPaths(body.text, attachments) + const queued = await queueMessage(ctx.db, { workspace: row, sentBy: caller.userId, agent: body.agent ?? 'claude', text, session: body.session }, now) + await auditCaller(ctx.db, caller, { action: 'workspace.message', targetType: 'workspace', targetId: row.id, detail: { messageId: queued.id, chars: body.text.length, continues: Boolean(body.session), attachments: attachments.length } }, now) // Queued now, delivered in the background (waking the VM if it sleeps); poll the message. ctx.waitUntil(deliverMessage(life, queued)) return json({ message: messageView(queued) }, 202, { location: `/v1/workspaces/${row.id}/messages/${queued.id}` }) diff --git a/cloud/apps/sandbox-control/src/api/vm-agent.ts b/cloud/apps/sandbox-control/src/api/vm-agent.ts index 970defd4880..d74e1b3bf25 100644 --- a/cloud/apps/sandbox-control/src/api/vm-agent.ts +++ b/cloud/apps/sandbox-control/src/api/vm-agent.ts @@ -78,14 +78,28 @@ async function orca(provider: SandboxProviderApi, sessionId: string, args: strin const LaunchResult = z.object({ outcome: z.object({ kind: z.string(), handle: z.string().optional() }).loose() }).loose() -/** Starts a new agent session with `prompt` in the workspace; returns its terminal handle. */ -export async function launchAgent(provider: SandboxProviderApi, sessionId: string, agent: AgentId, prompt: string): Promise { - const result = LaunchResult.safeParse( - await orca(provider, sessionId, ['agent', 'launch', '--agent', agent, '--worktree', `path:${PROJECT_ROOT}`, '--surface', 'terminal', `--prompt=${prompt}`], { - prepare: true, - timeoutMs: 90_000 - }) - ) +/** + * Starts a new agent session in the workspace, optionally with a first prompt and a model/effort + * pick (the CLI maps them onto the agent's own flags); returns its terminal handle. + */ +export async function launchAgent( + provider: SandboxProviderApi, + sessionId: string, + agent: AgentId, + prompt: string | null, + options: { model?: string; effort?: string } = {} +): Promise { + const args = ['agent', 'launch', '--agent', agent, '--worktree', `path:${PROJECT_ROOT}`, '--surface', 'terminal'] + if (options.model) { + args.push(`--model=${options.model}`) + if (options.effort) { + args.push(`--effort=${options.effort}`) + } + } + if (prompt) { + args.push(`--prompt=${prompt}`) + } + const result = LaunchResult.safeParse(await orca(provider, sessionId, args, { prepare: true, timeoutMs: 90_000 })) const handle = result.success ? result.data.outcome.handle : undefined if (!handle) { throw new VmAgentError('agent_launch_failed') @@ -98,6 +112,19 @@ export async function sendToSession(provider: SandboxProviderApi, sessionId: str await orca(provider, sessionId, ['terminal', 'send', '--terminal', handle, `--text=${text}`, '--enter'], { timeoutMs: 60_000 }) } +/** + * Stops the agent's current turn: one Escape, which the shipped agent CLIs treat as "interrupt" + * and which never quits an idle agent (Ctrl+C can, on a second press). Raw byte, no Enter. + */ +export async function interruptSession(provider: SandboxProviderApi, sessionId: string, handle: string): Promise { + await orca(provider, sessionId, ['terminal', 'send', '--terminal', handle, '--text=\u001b'], { timeoutMs: 30_000 }) +} + +/** Renames an agent session (its terminal tab title, which the desktop and phone show too). */ +export async function renameSession(provider: SandboxProviderApi, sessionId: string, handle: string, title: string): Promise { + await orca(provider, sessionId, ['terminal', 'rename', '--terminal', handle, `--title=${title}`], { timeoutMs: 30_000 }) +} + const TerminalList = z.object({ terminals: z.array( z.object({ diff --git a/cloud/apps/sandbox-control/src/auto-environments.ts b/cloud/apps/sandbox-control/src/auto-environments.ts new file mode 100644 index 00000000000..76476b97ab5 --- /dev/null +++ b/cloud/apps/sandbox-control/src/auto-environments.ts @@ -0,0 +1,168 @@ +// Automatic environments: Conductor-style "the repo is already there". An environment build (golden + +// the repo checked out, snapshotted) is opt-in for admins; without one every create of a repo cloned it +// from scratch (stablyai/orca: ~55 s). So the first create of a repo that no environment of the account +// lists makes a default environment for it (just the repo, blobless, no install script) and builds it in +// the background. Later creates boot from its active build (environments.ts resolveEnvironmentBoot) and +// only fetch what changed. Scoped per account like every environment; the usual golden refresh keeps +// it on the current image. Unused for 14 days it is deleted with its snapshots, unless an admin edited +// it (that makes it an ordinary 'org' environment). +import type { SandboxCaller } from './auth' +import { listBuilds, startBuild, TERMINAL, type BuildConfig, type BuildDeps } from './environment-builds' +import { canonicalRepoUrl, parseRepos, repoDir, type EnvironmentRow } from './environments' +import { normalizeRepo } from './secrets' + +export const AUTO_ENVIRONMENT_USER = 'system:auto-environment' +export const AUTO_ENVIRONMENT_UNUSED_MS = 14 * 24 * 60 * 60_000 +/** A failed automatic build is retried by a later create, at most this often. */ +export const AUTO_RETRY_AFTER_MS = 60 * 60_000 +/** Same cap as admin-made environments. */ +const MAX_ENVIRONMENTS = 20 + +const log = (event: string, fields: Record) => console.log(JSON.stringify({ event, ...fields })) + +function randomId(): string { + const bytes = crypto.getRandomValues(new Uint8Array(10)) + return `env_${Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('')}` +} + +function systemCaller(accountId: string): SandboxCaller { + // An org-less caller is its own admin (canAdminEnvironments); the build is billed to the account. + return { userId: AUTO_ENVIRONMENT_USER, accountId } +} + +function autoConfig(environment: EnvironmentRow): BuildConfig { + return { + revision: environment.revision, + repos: parseRepos(environment), + installScript: environment.install_script, + envVarNames: [], + machineSize: environment.machine_size, + // History and trees only: a smaller snapshot and a faster build; file contents load on demand. + cloneFilter: 'blob:none' + } +} + +export type AutoEnvironmentOutcome = 'created' | 'rebuilt' | 'exists' | 'skipped' + +/** + * A create of `repoUrl` booted without an environment: make (or retry building) the account's automatic + * environment for it. Never throws; the create it rides behind already succeeded. + */ +export async function ensureAutoEnvironment(deps: BuildDeps, accountId: string, repoUrl: string): Promise { + try { + return await ensure(deps, accountId, repoUrl) + } catch (error) { + log('auto_environment_failed', { error: String(error).slice(0, 200) }) + return 'skipped' + } +} + +async function ensure(deps: BuildDeps, accountId: string, repoUrl: string): Promise { + const url = canonicalRepoUrl(repoUrl) + const wanted = normalizeRepo(url) + if (!url || !wanted) { + return 'skipped' + } + const { results: environments } = await deps.db + .prepare('SELECT * FROM environments WHERE account_id = ? AND deleted_at IS NULL') + .bind(accountId) + .all() + const listing = environments.filter((row) => parseRepos(row).some((repo) => normalizeRepo(repo.url) === wanted)) + if (listing.some((row) => row.kind !== 'auto')) { + // An admin's environment lists the repo: theirs to build, never ours to shadow. + return 'exists' + } + const auto = listing[0] + if (auto) { + await touchEnvironment(deps.db, auto.id, deps.now()) + return (await retryFailedBuild(deps, auto)) ? 'rebuilt' : 'exists' + } + if (environments.length >= MAX_ENVIRONMENTS) { + return 'skipped' + } + const now = deps.now() + const id = randomId() + // UNIQUE(account_id, name): a concurrent first create of the same repo inserts nothing here. + await deps.db + .prepare( + `INSERT OR IGNORE INTO environments (id, account_id, name, repos, install_script, env_var_names, machine_size, + revision, next_build_number, created_by, updated_by, created_at, updated_at, kind, last_used_at) + VALUES (?, ?, ?, ?, '', '[]', 'standard', 1, 1, ?, ?, ?, ?, 'auto', ?)` + ) + .bind(id, accountId, repoDir(url), JSON.stringify([{ url, defaultBranch: null }]), AUTO_ENVIRONMENT_USER, + AUTO_ENVIRONMENT_USER, now, now, now) + .run() + const environment = await deps.db + .prepare('SELECT * FROM environments WHERE id = ? AND deleted_at IS NULL') + .bind(id) + .first() + if (!environment) { + return 'exists' + } + const build = await startBuild(deps, systemCaller(accountId), environment, { config: autoConfig(environment) }) + log('auto_environment_created', { environmentId: id, buildId: build.id }) + return 'created' +} + +/** No active build, none in flight, and the last one failed a while ago: try once more. */ +async function retryFailedBuild(deps: BuildDeps, environment: EnvironmentRow): Promise { + if (environment.active_build_id) { + return false + } + const [last] = await listBuilds(deps.db, environment.id, 1) + if (last && (!TERMINAL.has(last.status) || deps.now() - (last.finished_at ?? last.created_at) < AUTO_RETRY_AFTER_MS)) { + return false + } + await startBuild(deps, systemCaller(environment.account_id), environment, { config: autoConfig(environment) }) + return true +} + +/** A create booted from (or asked for) this environment. */ +export async function touchEnvironment(db: D1Database, environmentId: string, now: number): Promise { + await db.prepare('UPDATE environments SET last_used_at = ? WHERE id = ?').bind(now, environmentId).run() +} + +/** + * Deletes the environment and every snapshot it built (live workspaces run on their own disks). + * Shared by an admin's Delete and the automatic expiry. + */ +export async function deleteEnvironmentAndSnapshots( + deps: Pick, + environmentId: string +): Promise { + await deps.db + .prepare('UPDATE environments SET deleted_at = ?, active_build_id = NULL WHERE id = ?') + .bind(deps.now(), environmentId) + .run() + const { results } = await deps.db + .prepare(`SELECT id, snapshot_id FROM environment_builds WHERE environment_id = ? AND snapshot_id IS NOT NULL AND snapshot_deleted_at IS NULL`) + .bind(environmentId) + .all<{ id: string; snapshot_id: string }>() + for (const row of results) { + await deps.provider.deleteSnapshot(row.snapshot_id).catch(() => undefined) + await deps.db.prepare('UPDATE environment_builds SET snapshot_deleted_at = ? WHERE id = ?').bind(deps.now(), row.id).run() + } +} + +/** Cron: automatic environments no create used for 14 days go, with their snapshots. */ +export async function expireAutoEnvironments(deps: BuildDeps): Promise { + const cutoff = deps.now() - AUTO_ENVIRONMENT_UNUSED_MS + const { results } = await deps.db + .prepare( + `SELECT id FROM environments WHERE kind = 'auto' AND deleted_at IS NULL + AND COALESCE(last_used_at, created_at) < ? LIMIT 20` + ) + .bind(cutoff) + .all<{ id: string }>() + let expired = 0 + for (const { id } of results) { + const inFlight = (await listBuilds(deps.db, id, 5)).some((build) => !TERMINAL.has(build.status)) + if (inFlight) { + continue + } + await deleteEnvironmentAndSnapshots(deps, id) + log('auto_environment_expired', { environmentId: id }) + expired++ + } + return expired +} diff --git a/cloud/apps/sandbox-control/src/clone-status.ts b/cloud/apps/sandbox-control/src/clone-status.ts index 2e3411b24b5..b162cd27ae1 100644 --- a/cloud/apps/sandbox-control/src/clone-status.ts +++ b/cloud/apps/sandbox-control/src/clone-status.ts @@ -40,7 +40,8 @@ export function parseCloneStatus(stdout: string): CloneStatus { if (state === 'none' || state === '') { return { state: 'none' } } - if (state === 'done') { + if (state === 'done' || state.startsWith('done ')) { + // "done stale": an update after an environment boot failed; the build's checkout still opens. return { state: 'done' } } if (state.startsWith('failed')) { diff --git a/cloud/apps/sandbox-control/src/env.ts b/cloud/apps/sandbox-control/src/env.ts index 9223685fff2..c0c9c9faa5a 100644 --- a/cloud/apps/sandbox-control/src/env.ts +++ b/cloud/apps/sandbox-control/src/env.ts @@ -23,10 +23,18 @@ export type Env = { GOLDEN_SNAPSHOT_REGION?: string /** Non-prod only: pin this image over the rotated active one (preview versions testing new VM entry points). */ GOLDEN_SNAPSHOT_OVERRIDE?: string + /** 'off': no automatic environments (auto-environments.ts); creates without one keep cloning. */ + AUTO_ENVIRONMENTS?: string /** Git as the sender: `on`, `accounts:,` or off (default). See memberGitEnabled in index.ts. */ MEMBER_GIT_IDENTITY?: string /** How long after a member's own send their GitHub identity stays usable (default 30). */ MEMBER_GIT_WINDOW_MINUTES?: string + /** + * Who sees a member's daily activity heatmap on their profile. `opt_in` (default): only members + * who turned on "Pokes and activity". `team`: every teammate (Conductor's default). Config only, + * so flipping it needs no migration. + */ + TEAMMATE_ACTIVITY_SHARING?: string /** `release:latest` | `release:v1.2.3`: build golden images from Orca's released orca-server tarball. */ GOLDEN_IMAGE_SOURCE?: string /** TTL for Worker-built golden images; unset/0 keeps them until rotated out. */ @@ -124,6 +132,12 @@ export type Env = { /** Operator routes (/v1/internal/*): kill switch, drain, bindings. Secret, >= 32 chars; unset = no routes. */ OPERATOR_TOKEN?: string + /** + * Auth's bearer for POST /v1/internal/org-members/removed only (PropelAuth offboarding and + * Orca-side removals). Secret, >= 32 chars; lets auth push removals without holding the + * operator token. The operator token is still accepted on that route. + */ + MEMBER_REMOVED_TOKEN?: string /** `true` refuses every create/resume/rollover (static kill switch; the D1 flag is the runtime one). */ SANDBOX_CREATES_DISABLED?: string /** Warm pool size (pool.ts); unset or 0 = off. */ diff --git a/cloud/apps/sandbox-control/src/environment-builds.ts b/cloud/apps/sandbox-control/src/environment-builds.ts index f0d02aaadcf..972bbd360f2 100644 --- a/cloud/apps/sandbox-control/src/environment-builds.ts +++ b/cloud/apps/sandbox-control/src/environment-builds.ts @@ -91,6 +91,8 @@ export type BuildConfig = { installScript: string envVarNames: string[] machineSize: MachineSize + /** `git clone --filter`: automatic environments clone blobless (auto-environments.ts). */ + cloneFilter?: 'blob:none' } export type BuildResult = { @@ -338,7 +340,8 @@ async function bootBuild(deps: BuildDeps, row: BuildRow, config: BuildConfig): P ORCA_BUILD_REPOS: lines.join('\n'), ORCA_INSTALL_SCRIPT_B64: base64(config.installScript), ORCA_LOCKFILES: LOCKFILES.join(' '), - ORCA_DEPS_HOOK_B64: base64(ENVIRONMENT_DEPS_HOOK) + ORCA_DEPS_HOOK_B64: base64(ENVIRONMENT_DEPS_HOOK), + ...(config.cloneFilter ? { ORCA_CLONE_FILTER: config.cloneFilter } : {}) } log('environment_build_secrets', { buildId: row.id, injected: Object.keys(secrets).length, named: config.envVarNames.length }) const commandId = await deps.provider.startCommand(box.session.id, { diff --git a/cloud/apps/sandbox-control/src/environment-routes.ts b/cloud/apps/sandbox-control/src/environment-routes.ts index c8120dbe085..a1edaae0abc 100644 --- a/cloud/apps/sandbox-control/src/environment-routes.ts +++ b/cloud/apps/sandbox-control/src/environment-routes.ts @@ -9,6 +9,7 @@ // GET /v1/environments/:id/builds/:bid/events -> ndjson stream (environment-builds.ts) // POST /v1/environments/:id/builds/:bid/cancel | /activate -> {build} | {environment} // GET /v1/environments/:id/staleness -> {staleness} +import { deleteEnvironmentAndSnapshots } from './auto-environments' import type { SandboxCaller } from './auth' import { activateBuild, @@ -163,16 +164,8 @@ export async function handleEnvironmentRoute( await cancelBuild(deps, caller, row).catch(() => undefined) } } - await db.prepare('UPDATE environments SET deleted_at = ?, active_build_id = NULL WHERE id = ?').bind(deps.now(), envId).run() // No kept window once deleted: every build snapshot goes (live workspaces run on their own disks). - const { results } = await db - .prepare(`SELECT * FROM environment_builds WHERE environment_id = ? AND snapshot_id IS NOT NULL AND snapshot_deleted_at IS NULL`) - .bind(envId) - .all() - for (const row of results) { - await deps.provider.deleteSnapshot(row.snapshot_id!).catch(() => undefined) - await db.prepare('UPDATE environment_builds SET snapshot_deleted_at = ? WHERE id = ?').bind(deps.now(), row.id).run() - } + await deleteEnvironmentAndSnapshots(deps, envId) return json({ deleted: true }) } return json({ error: 'not_found' }, 404) diff --git a/cloud/apps/sandbox-control/src/environments.ts b/cloud/apps/sandbox-control/src/environments.ts index 39674e57c5a..25a37008848 100644 --- a/cloud/apps/sandbox-control/src/environments.ts +++ b/cloud/apps/sandbox-control/src/environments.ts @@ -31,6 +31,12 @@ export type EnvironmentRow = { created_at: number updated_at: number deleted_at: number | null + /** + * 'org': made (or since edited) by an admin. 'auto': made by the first create of a repo no + * environment listed (auto-environments.ts); deleted after 14 days unused unless an admin edits it. + */ + kind?: 'org' | 'auto' + last_used_at?: number | null } export class EnvironmentError extends Error { @@ -223,10 +229,11 @@ export async function updateEnvironment( next.install_script !== row.install_script || next.env_var_names !== row.env_var_names || next.machine_size !== row.machine_size + // An admin's edit adopts an automatic environment: it stops expiring. const result = await db .prepare( `UPDATE environments SET name = ?, repos = ?, install_script = ?, env_var_names = ?, machine_size = ?, - revision = revision + ?, updated_by = ?, updated_at = ? WHERE id = ? AND revision = ?` + revision = revision + ?, updated_by = ?, updated_at = ?, kind = 'org' WHERE id = ? AND revision = ?` ) .bind(next.name, next.repos, next.install_script, next.env_var_names, next.machine_size, buildInputsChanged ? 1 : 0, caller.userId, now, row.id, row.revision) @@ -246,6 +253,8 @@ export type BootSource = { machineSize: MachineSize /** The build's snapshot only boots here, so the workspace is created here too. */ region: string + /** An automatic environment (auto-environments.ts): the caller's machine size stands. */ + auto?: boolean } type BootBuildRow = { @@ -288,7 +297,12 @@ function bootFrom(build: BootBuildRow, repoUrl: string | null | undefined): Boot export async function resolveEnvironmentBoot( db: D1Database, accountId: string, - request: { repoUrl?: string | null; buildId?: string | null } + request: { + repoUrl?: string | null + buildId?: string | null + /** An automatic environment only boots in its build's region: an explicit other region skips it. */ + region?: string | null + } ): Promise { if (request.buildId) { const build = await db @@ -308,20 +322,25 @@ export async function resolveEnvironmentBoot( if (!wanted) { return null } + // An admin's environment that lists the repo wins over an automatic one. const { results } = await db .prepare( - `SELECT e.repos AS repos, b.* FROM environments e JOIN environment_builds b ON b.id = e.active_build_id - WHERE e.account_id = ? AND e.deleted_at IS NULL ORDER BY e.updated_at DESC` + `SELECT e.repos AS repos, e.kind AS kind, b.* FROM environments e JOIN environment_builds b ON b.id = e.active_build_id + WHERE e.account_id = ? AND e.deleted_at IS NULL ORDER BY (e.kind = 'org') DESC, e.updated_at DESC` ) .bind(accountId) - .all() + .all() for (const row of results) { if (!parseRepos(row).some((repo) => normalizeRepo(repo.url) === wanted)) { continue } + // An automatic environment is only a speed-up: an explicit other region skips it. + if (row.kind === 'auto' && request.region && request.region !== row.region) { + continue + } const source = bootFrom(row, request.repoUrl) if (source?.repoDir) { - return source + return row.kind === 'auto' ? { ...source, auto: true } : source } } return null diff --git a/cloud/apps/sandbox-control/src/index.ts b/cloud/apps/sandbox-control/src/index.ts index 88fd55ca1bc..80752e89649 100644 --- a/cloud/apps/sandbox-control/src/index.ts +++ b/cloud/apps/sandbox-control/src/index.ts @@ -9,6 +9,7 @@ // the public API's POST /v1/workspaces/:id/wake answers the same fields plus `workspace`) // POST /v1/sandboxes/:id/restart -> {sandbox, connection} // GET /v1/sandboxes/:id/status -> {sandbox, status} (live metrics, cost) +// GET /v1/sandboxes/boot-plan?repo= -> {repo: 'clone' | 'update'} // GET /v1/sandboxes/:id/clone -> {clone: {state, percent?, stage?, reason?}} // POST /v1/sandboxes/:id/archive {pullRequests?, checkouts?} -> {sandbox} // GET /v1/sandboxes/:id/archive -> {archive} @@ -24,10 +25,13 @@ // POST /v1/device-sessions | GET | DELETE /:id per-phone access (see device-sessions.ts) // Phones sign their own EdDSA tokens (device-sessions.ts) and act as their user, except that they // cannot enroll devices, manage secrets or connect GitHub. -// /v1/team/workspaces[/:id[/presence|wake|lease|grants[/:grantId]]], /v1/team/links/resolve, /v1/team/prompts +// /v1/team/workspaces[/:id[/presence|wake|lease|grants[/:grantId]]], /v1/team/links/resolve, /v1/team/prompts, +// /v1/team/prefs (src/workspace-prefs.ts), /v1/team/org (src/org-slugs.ts) // team workspace registry, presence, per-device grants (src/workspaces.ts, src/grants.ts) // POST /v1/team/workspaces/:id/wake?wait=30s: any member who can open it wakes it (single-flight, // billed to the account, counted on the owner's seat like every wake) -> {state, endpoint: null, …} +// /v1/team/members/:userId/(profile|poke), /v1/team/pokes[/settings|/seen] +// teammate profiles (usage heatmap, recent workspaces) and opt-in Pokes (src/team-presence.ts) // /v1/sandboxes/* is the owner's lifecycle API: only the workspace's owner (and, for suspend and // destroy, an org admin) can reach a row there, because resume hands back an orcad pairing offer. // Browser (GitHub redirects): GET /v1/github/setup, GET /v1/github/callback @@ -114,7 +118,7 @@ import { egressAccountRoutes, egressSecretHosts, placeholderValues, secretPlaceh import { SecretError, handleSecretsRoute, keyringFor, type SecretChange } from './secrets' import { refreshAfterSecretChange, refreshSandboxEnv } from './env-refresh' import { accountProvider, isSharedWorkspace } from './account-providers' -import { handleAccountUnauthorized } from './agent-credential-checks' +import { handleAccountUnauthorized, verifyAccountCredential } from './agent-credential-checks' import { codexBrokerTick, handleCodexBrokerRoute, type BrokerDeps } from './codex-broker' import { refreshCodexLeases } from './codex-credentials' import { @@ -141,6 +145,9 @@ import { credentialTargets, type CredentialTarget } from './provider-env' import type { Keyring } from './secrets-crypto' import { ProviderError, type SandboxProviderApi } from './sandbox-provider' import { readCloneStatus } from './clone-status' +import { readIdempotencyKey, withIdempotency } from './api/idempotency' +import { ApiError } from './api/caller' +import { ensureAutoEnvironment, expireAutoEnvironments, touchEnvironment } from './auto-environments' import { DesktopCommandError, VmCommandError, startDesktop } from './sandbox-vm-commands' import { forgetShareLink, handleShareGateway } from './share-gateway' import { handleShareRoute, revokeSandboxShares, sharePathMode, shareSecret, shareSecrets } from './share-links' @@ -150,7 +157,7 @@ import { getSandbox, getSandboxByProviderName, listAccountSandboxes, markUserSle import { createVercelSandboxApi } from './vercel-sandbox-api' import { advanceAllBuilds, tickBuild, unfinishedBuilds, type BuildDeps } from './environment-builds' import { environmentErrorResponse, handleEnvironmentRoute, isEnvironmentRoute } from './environment-routes' -import { EnvironmentError } from './environments' +import { EnvironmentError, resolveEnvironmentBoot } from './environments' import type { GoldenImageProviderApi } from './golden-image-provider' import { CreateRequestSchema, LeaseRequestSchema, parseWakeWait, readyView, sandboxView } from './wire' import { ArchiveRequestSchema } from './sandbox-vm-inspect' @@ -185,7 +192,10 @@ import { userAuthorizeUrl } from './github-user-tokens' import { MEMBER_GIT_WINDOW_MS, memberGitRoutes, memberSentWithin, recordMemberSend } from './member-git' +import { getWorkspacePrefs, putWorkspacePrefs } from './workspace-prefs' +import { getOrgSlug, putOrgSlug } from './org-slugs' import { + LinkOtherOrgError, PatchSchema, PresenceSchema, WORKSPACE_ERROR_STATUS, @@ -201,6 +211,7 @@ import { workspaceViews } from './workspaces' import { rememberCallerName } from './member-names' +import { TeamPresenceError, teamPresenceRoute } from './team-presence' import { sweepSessionCpu } from './session-cpu' import type { SandboxCaller } from './auth' @@ -529,6 +540,28 @@ async function agentCredentialsRoute(request: Request, url: URL, env: Env, deps: await refreshOwnersSandboxes(env, deps, caller.userId) return noStore(await agentCredentialsView(db, env, caller.userId, now)) } + // Pre-launch check (desktop): a recent pass answers at once; otherwise one rate-limited auth check with + // the real token, revoking only on a definite auth failure (agent-credential-checks.ts). + if (request.method === 'POST' && url.pathname === '/v1/agent-credentials/claude/verify') { + const provider = accountProvider('claude') + if (!providerEnabled(env).claude || !provider) { + return fail('not_found', 404) + } + const result = await verifyAccountCredential({ + db, + keyring: await keyring, + provider, + userId: caller.userId, + now, + fetch: deps.egressFetch ?? fetch + }) + if (result.outcome === 'revoked') { + forgetAccountCredential(caller.userId, 'claude') + await refreshOwnersSandboxes(env, deps, caller.userId) + } + const view = await agentCredentialsView(db, env, caller.userId, now) + return noStore({ claude: view.claude, verifiedAt: result.verifiedAt, checked: result.outcome !== 'fresh' && result.outcome !== 'skipped' }) + } if (url.pathname === '/v1/agent-credentials/codex/broker' || url.pathname.startsWith('/v1/agent-credentials/codex/broker/')) { return await handleCodexBrokerRoute(request, url, { enabled: providerEnabled(env).codex, deps: await codexBrokerDeps(env, deps), caller }) } @@ -720,8 +753,8 @@ function devCredentials(env: Env): CredentialBroker { } /** Ready answers carry phase timings as Server-Timing so clients and dashboards can see the slow step. */ -function readyResponse(ready: Ready): Response { - const response = json(readyView(ready.row, ready.connection, ready.cloning)) +function readyResponse(ready: Ready, updateAware = false): Response { + const response = json(readyView(ready.row, ready.connection, ready.cloning, updateAware)) const timing = Object.entries(ready.timings ?? {}) .map(([phase, ms]) => `${phase};dur=${ms}`) .join(', ') @@ -780,7 +813,7 @@ export async function lifecycleDeps(env: Env, deps: Deps): Promise ensureAutoEnvironment(buildDeps(life, deps, env), accountId, repoUrl), + touch: (environmentId) => touchEnvironment(env.SANDBOX_DB, environmentId, life.now()) + } + } + return life } /** @@ -1109,7 +1150,12 @@ export async function handleRequest(request: Request, env: Env, deps: Deps = {}) return await internalInstallUrl(env, deps, url) } if (url.pathname.startsWith('/v1/internal/')) { - if (!(await isOperator(request, env.OPERATOR_TOKEN))) { + // Auth's member-removed push holds a token good for that one route, not the operator token. + const memberRemovedOnly = + url.pathname === '/v1/internal/org-members/removed' && + request.method === 'POST' && + (await isOperator(request, env.MEMBER_REMOVED_TOKEN)) + if (!memberRemovedOnly && !(await isOperator(request, env.OPERATOR_TOKEN))) { return fail('not_found', 404) } const life = await lifecycleDeps(env, deps) @@ -1449,7 +1495,12 @@ export async function handleRequest(request: Request, env: Env, deps: Deps = {}) url.pathname === '/v1/team/workspaces' || url.pathname.startsWith('/v1/team/workspaces/') || url.pathname === '/v1/team/links/resolve' || - url.pathname === '/v1/team/prompts' + url.pathname === '/v1/team/prompts' || + url.pathname === '/v1/team/prefs' || + url.pathname === '/v1/team/org' || + url.pathname.startsWith('/v1/team/members/') || + url.pathname === '/v1/team/pokes' || + url.pathname.startsWith('/v1/team/pokes/') ) { const caller = await authenticateDesktop(env, request, (deps.now ?? Date.now)()) if (!caller) { @@ -1457,6 +1508,20 @@ export async function handleRequest(request: Request, env: Env, deps: Deps = {}) } return await workspaceRoute(request, url, env, deps, caller) } + if (url.pathname === '/v1/sandboxes/boot-plan' && request.method === 'GET') { + // Whether a create of this repo would clone it or update a prebuilt copy, so the desktop names + // its repository step once, before the create answers (environments.ts resolveEnvironmentBoot). + const caller = await authenticateDesktop(env, request, (deps.now ?? Date.now)()) + if (!caller) { + return fail('unauthorized', 401) + } + const repo = url.searchParams.get('repo') ?? '' + if (repo.length === 0 || repo.length > 2048) { + return fail('invalid_request', 400) + } + const source = await resolveEnvironmentBoot(env.SANDBOX_DB, caller.accountId, { repoUrl: repo }).catch(() => null) + return json({ repo: source?.repoDir ? 'update' : 'clone' }) + } const match = /^\/v1\/sandboxes(?:\/([A-Za-z0-9_]+)(?:\/(suspend|resume|lease|rollover|wake|restart|status|clone|archive|unarchive|env\/refresh|egress\/hosts|ssh-keys|desktop))?)?$/.exec( url.pathname @@ -1492,14 +1557,39 @@ export async function handleRequest(request: Request, env: Env, deps: Deps = {}) return fail('not_found', 404) } await consumeCreateToken(life.db, life.config.guardrails!, caller.accountId, life.now()) - const body = CreateRequestSchema.safeParse(await readJson(request)) + const raw = await readJson(request) + const body = CreateRequestSchema.safeParse(raw) if (!body.success) { return fail('invalid_request', 400) } - // Desktops that show the clone as its own step ask for it in the background (GET .../clone). - const ready = await createSandbox(life, caller, { ...body.data, cloneInBackground: features.includes('clone-progress') }) - await recordOwnerDeviceAndSync(life, ready.row, ready.connection.pairingCode) - return readyResponse(ready) + // Idempotency-Key (one per Create press): a re-sent create with the same key and body answers + // with the sandbox the first one made, for 24 h, instead of starting another (PC-8). + let timings: Ready['timings'] + try { + const response = await withIdempotency( + life.db, + { accountId: caller.accountId, scope: `sandbox.create:${caller.userId}`, key: readIdempotencyKey(request), body: raw, now: life.now() }, + async () => { + // Desktops that show the clone as its own step ask for it in the background (GET .../clone). + const ready = await createSandbox(life, caller, { ...body.data, cloneInBackground: features.includes('clone-progress') }) + await recordOwnerDeviceAndSync(life, ready.row, ready.connection.pairingCode) + timings = ready.timings + return { status: 200, body: readyView(ready.row, ready.connection, ready.cloning, features.includes('repo-update')) } + } + ) + const timing = Object.entries(timings ?? {}) + .map(([phase, ms]) => `${phase};dur=${ms}`) + .join(', ') + if (timing) { + response.headers.set('server-timing', timing) + } + return response + } catch (error) { + if (error instanceof ApiError) { + return fail(error.code, error.status, error.reason) + } + throw error + } } const row = await getSandbox(env.SANDBOX_DB, id) const route = `${request.method} ${action ?? ''}` @@ -1787,7 +1877,32 @@ async function workspaceRoute(request: Request, url: URL, env: Env, deps: Deps, // Labels for teammates' lists; a failure here must never fail the request itself. await rememberCallerName(db, caller, now).catch((error: unknown) => console.warn('member_name_write_failed', String(error))) if (url.pathname === '/v1/team/links/resolve' && request.method === 'GET') { - return json(await resolveLink(db, caller, url, now)) + try { + return json(await resolveLink(db, caller, url, now)) + } catch (error) { + if (error instanceof LinkOtherOrgError) { + return json({ error: 'not_found', reason: 'other_org', orgId: error.orgId }, 404) + } + throw error + } + } + if (url.pathname === '/v1/team/prefs') { + if (request.method === 'GET') { + return json(await getWorkspacePrefs(db, caller)) + } + if (request.method === 'PUT') { + return json(await putWorkspacePrefs(db, caller, await readJson(request), now)) + } + return fail('not_found', 404) + } + if (url.pathname === '/v1/team/org') { + if (request.method === 'GET') { + return json(await getOrgSlug(db, caller, url, now)) + } + if (request.method === 'PUT') { + return json(await putOrgSlug(db, caller, await readJson(request), now)) + } + return fail('not_found', 404) } if (url.pathname === '/v1/team/prompts') { if (request.method === 'GET') { @@ -1801,6 +1916,26 @@ async function workspaceRoute(request: Request, url: URL, env: Env, deps: Deps, if (url.pathname === '/v1/team/workspaces') { return request.method === 'GET' ? json(await listWorkspaces(db, caller, url, now)) : fail('not_found', 404) } + if (url.pathname.startsWith('/v1/team/members/') || url.pathname.startsWith('/v1/team/pokes')) { + try { + const answer = await teamPresenceRoute(db, caller, request, url, now, () => readJson(request), { + activitySharing: env.TEAMMATE_ACTIVITY_SHARING === 'team' ? 'team' : 'opt_in' + }) + return answer === null ? fail('not_found', 404) : json(answer) + } catch (error) { + if (error instanceof TeamPresenceError) { + const response = json( + { error: error.code, ...(error.reason ? { reason: error.reason } : {}), ...(error.retryAfterMs ? { retryAfterMs: error.retryAfterMs } : {}) }, + error.status + ) + if (error.retryAfterMs) { + response.headers.set('retry-after', String(Math.ceil(error.retryAfterMs / 1000))) + } + return response + } + throw error + } + } const match = /^\/v1\/team\/workspaces\/(sbx_[0-9a-f]{24})(?:\/(presence|wake|lease|grants|sent|read-snapshot)(?:\/(grt_[0-9a-f]{24}))?)?$/.exec(url.pathname) if (!match) { return fail('not_found', 404) @@ -2116,6 +2251,11 @@ export default { if (refresh.stale > 0) { console.log(JSON.stringify({ event: 'environment_golden_refresh', ...refresh })) } + // Automatic environments unused for 14 days go with their snapshots (storage). + const expired = await expireAutoEnvironments(buildDeps(fresh, {}, env)).catch(() => 0) + if (expired > 0) { + console.log(JSON.stringify({ event: 'auto_environments_expired', expired })) + } } }) ) diff --git a/cloud/apps/sandbox-control/src/lifecycle.ts b/cloud/apps/sandbox-control/src/lifecycle.ts index 9d3d7e4cf46..7532dda648e 100644 --- a/cloud/apps/sandbox-control/src/lifecycle.ts +++ b/cloud/apps/sandbox-control/src/lifecycle.ts @@ -28,6 +28,7 @@ import { ORCAD_PORT, SHARE_PROXY_PORT, VmCommandError, + workspaceHostname, drainOrcad, runningOrcad, startOrcad, @@ -96,6 +97,14 @@ export type LifecycleDeps = { * error after boot. Absent: no check. */ publicRepoCheck?: (repoUrl: string) => Promise + /** + * Automatic environments (auto-environments.ts): `ensure` after a create of a repo no environment + * lists, `touch` when a create booted from an automatic one. Absent: neither happens. + */ + autoEnvironment?: { + ensure(accountId: string, repoUrl: string): Promise + touch(environmentId: string): Promise + } /** Work that may finish after the response (Worker ctx.waitUntil); absent means fire-and-forget. */ background?: (work: Promise) => void /** Best-effort side effects of a session starting or ending (workspace tokens, see api/settings.ts). */ @@ -156,8 +165,11 @@ export type Ready = { row: SandboxRow connection: OrcadReady timings?: Record - /** The repo is still cloning in the VM (create with cloneInBackground); GET /clone reports it. */ - cloning?: boolean + /** + * The repo is still being cloned ('clone') or, after an environment boot, brought up to date + * ('update') in the VM (create with cloneInBackground); GET /clone reports it. + */ + cloning?: 'clone' | 'update' } /** Phase durations for one lifecycle call (logged + Server-Timing); counts only, no ids or secrets. */ @@ -376,6 +388,8 @@ async function boot( options.timer.time('orcad', async () => startOrcad(deps.provider, state, { sandboxId: row.id, + // The workspace's name, else its repo's: never the provider's per-boot VM id. + hostname: workspaceHostname(row.name ?? (row.repo_url ? parseGitHubRepo(row.repo_url)?.repo : null)), repo: options.repo, // Repos hosted outside github.com get no GitHub credential, not even the placeholder. githubPlaceholder: deps.config.egressProxyUrl && parseGitHubRepo(row.repo_url ?? '') ? githubPlaceholderToken(row) : undefined, @@ -515,11 +529,13 @@ export async function createSandbox( ? await timer.time('environment', () => resolveEnvironmentBoot(deps.db, caller.accountId, { repoUrl: request.repo?.url, - buildId: request.environmentBuildId + buildId: request.environmentBuildId, + region: request.region }) ) : null - const machineSize = source?.machineSize ?? request.machineSize + // An automatic environment is only the repo checked out: the caller's machine size stands. + const machineSize = source && !source.auto ? source.machineSize : request.machineSize await timer.time('entitlement', () => requireStart(deps, caller.accountId, caller.userId, machineSize)) // A snapshot only boots in its own region: an environment build pins the region it was built in. const region = source?.region ?? request.region ?? deps.config.defaultRegion @@ -541,12 +557,16 @@ export async function createSandbox( deps.background?.(refill) } const claimedAt = deps.now() - // An environment build carries the repo prebuilt: nothing clones, so nothing runs in the background. - const cloneInBackground = Boolean(request.repo && request.cloneInBackground && !source?.repoDir) + // In the background after ready: a clone, or (an environment build carries the repo prebuilt) a fetch + // of what changed since the build. + const cloning: Ready['cloning'] = request.repo && request.cloneInBackground ? (source?.repoDir ? 'update' : 'clone') : undefined const prelude: StartInputs['prelude'] = request.repo ? { script: WORKSPACE_PRELUDE_SCRIPT, - env: source?.repoDir ? { ORCA_ENV_REPO_DIR: source.repoDir } : cloneInBackground ? { ORCA_CLONE_BACKGROUND: '1' } : {} + env: { + ...(source?.repoDir ? { ORCA_ENV_REPO_DIR: source.repoDir } : {}), + ...(cloning ? { ORCA_CLONE_BACKGROUND: '1' } : {}) + } } : undefined const id = pooled?.id ?? randomId() @@ -590,6 +610,18 @@ export async function createSandbox( throw error } }) + // The repo is reachable: the next create of it should find it prebuilt (auto-environments.ts). + if (request.repo && deps.autoEnvironment && !request.environmentBuildId && request.useEnvironment !== false) { + const work = source?.auto + ? deps.autoEnvironment.touch(source.environmentId) + : !source + ? deps.autoEnvironment.ensure(caller.accountId, request.repo.url) + : null + if (work) { + const settled = work.catch(() => undefined) + deps.background?.(settled) + } + } if (pooled) { try { const state = await timer.time('vm', () => @@ -597,7 +629,7 @@ export async function createSandbox( ) const ready = await boot(deps, row, state, prep, { repo: request.repo, policyApplied: true, timer, billFrom: claimedAt, prelude }) console.log(JSON.stringify({ event: 'lifecycle_timing', op: 'create', pooled: true, ms: timer.timings })) - return cloneInBackground ? { ...ready, cloning: true } : ready + return cloning ? { ...ready, cloning } : ready } catch (error) { // A pooled VM that will not take the session is discarded; the caller still gets a workspace. console.log(JSON.stringify({ event: 'pool_adopt_failed', error: String(error).slice(0, 200) })) @@ -647,7 +679,7 @@ export async function createSandbox( try { const ready = await boot(deps, row, state, prep, { repo: request.repo, policyApplied: true, timer, prelude }) console.log(JSON.stringify({ event: 'lifecycle_timing', op: 'create', fromBuild: source?.buildId ?? null, ms: timer.timings })) - return cloneInBackground ? { ...ready, cloning: true } : ready + return cloning ? { ...ready, cloning } : ready } catch (error) { await failAndRelease(deps, (await getSandbox(deps.db, row.id)) ?? row, createFailureReason(error)) throw error diff --git a/cloud/apps/sandbox-control/src/mcp/server.ts b/cloud/apps/sandbox-control/src/mcp/server.ts index 1c737b3c60a..3a2b3d672e6 100644 --- a/cloud/apps/sandbox-control/src/mcp/server.ts +++ b/cloud/apps/sandbox-control/src/mcp/server.ts @@ -5,7 +5,8 @@ import type { ApiCaller } from '../api/caller' import { callTool, hasTool, toolError, toolList, type ApiCall } from './tools' export const PROTOCOL_VERSIONS = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05'] as const -const MAX_BODY_BYTES = 256 * 1024 +// upload_attachment carries up to 5 MB as base64 (~6.7 MB of JSON); everything else is tiny. +const MAX_BODY_BYTES = 7 * 1024 * 1024 + 512 * 1024 const SERVER_INFO = { name: 'orca-cloud', @@ -16,7 +17,8 @@ const SERVER_INFO = { const INSTRUCTIONS = 'Orca Cloud runs coding agents (Claude Code, Codex) in cloud workspaces. Typical flow: list_projects or list_workspaces; ' + - 'create_workspace (optionally with a first message); send_message to give an agent a task; list_sessions to read its progress; ' + + 'create_workspace (optionally with a first message); send_message to give an agent a task; list_sessions and read_session to read its progress; ' + + 'create_session for another chat (pick models with list_models), upload_attachment to hand an agent a file, cancel_session to stop a turn; ' + 'sleep_workspace when idle and destroy_workspace when done. Destroying is permanent.' type JsonRpcId = string | number | null diff --git a/cloud/apps/sandbox-control/src/mcp/tools.ts b/cloud/apps/sandbox-control/src/mcp/tools.ts index a01351185d2..9977bfb4626 100644 --- a/cloud/apps/sandbox-control/src/mcp/tools.ts +++ b/cloud/apps/sandbox-control/src/mcp/tools.ts @@ -32,6 +32,7 @@ type ToolDef = { // Ids go into URL paths: restrict them so a tool argument can never address another route. const Id = (what: string) => z.string().regex(/^[A-Za-z0-9_-]{1,64}$/, `a ${what} id`).describe(`The ${what} id.`) const WorkspaceId = z.object({ workspaceId: Id('workspace') }).strict() +const SessionHandle = z.string().regex(/^term_[A-Za-z0-9-]{1,80}$/).describe('Session handle (term_…) from list_sessions, create_session or a message.') const Agent = z.enum(AGENTS).describe(`Agent CLI to run: ${AGENTS.join(', ')} (claude, Claude Code, is the default).`) const MAX_WAIT_SECONDS = 45 @@ -92,6 +93,14 @@ export const TOOLS = [ annotations: read('Who am I'), run: async (_args, api) => fromApi(await api('GET', '/v1/me')) }), + tool({ + name: 'list_models', + description: + 'Lists the coding agents a cloud workspace runs (claude, codex, opencode, gemini, cursor, copilot) and, for each, the model ids, effort levels, defaults and fast-mode support. Pass agent, model and effort to create_session.', + input: z.object({}).strict(), + annotations: read('List agents and models'), + run: async (_args, api) => fromApi(await api('GET', '/v1/models')) + }), tool({ name: 'list_projects', description: 'Lists the Orca Cloud projects in this account. A project is a repository plus default sandbox settings; pass its id to create_workspace to start a workspace from it.', @@ -153,6 +162,13 @@ export const TOOLS = [ }) ) }), + tool({ + name: 'rename_workspace', + description: 'Renames a workspace (the name shown on desktop Home, the phone and in list_workspaces). The git branch keeps its name.', + input: z.object({ workspaceId: Id('workspace'), name: z.string().trim().min(1).max(100).describe('New display name.') }).strict(), + annotations: { title: 'Rename workspace', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }, + run: async (args, api) => fromApi(await api('POST', `/v1/workspaces/${args.workspaceId}/rename`, { name: args.name })) + }), tool({ name: 'sleep_workspace', description: 'Puts a running workspace to sleep: its files are kept and no sandbox hours are used until wake_workspace. Running agents are interrupted.', @@ -174,6 +190,13 @@ export const TOOLS = [ annotations: { title: 'Archive workspace', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }, run: async (args, api) => fromApi(await api('POST', `/v1/workspaces/${args.workspaceId}/archive`)) }), + tool({ + name: 'unarchive_workspace', + description: 'Restores an archived workspace: it is back in default lists and its sandbox is started again with its files intact. A workspace that is not archived is returned unchanged.', + input: WorkspaceId, + annotations: { title: 'Unarchive workspace', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }, + run: async (args, api) => fromApi(await api('POST', `/v1/workspaces/${args.workspaceId}/unarchive`)) + }), tool({ name: 'destroy_workspace', description: 'Deletes a workspace and its sandbox for good. Uncommitted and unpushed work in it is lost. This cannot be undone.', @@ -181,6 +204,53 @@ export const TOOLS = [ annotations: { title: 'Delete workspace', readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }, run: async (args, api) => fromApi(await api('DELETE', `/v1/workspaces/${args.workspaceId}`)) }), + tool({ + name: 'create_session', + description: + 'Starts a new agent session (a new chat) in an existing workspace, waking it first if it sleeps, and returns its handle once the agent is up. Optionally pick the model and effort (see list_models), name it, and give it a first `message` (with `attachments` from upload_attachment). Continue it with send_message and `session` = the handle.', + input: z + .object({ + workspaceId: Id('workspace'), + agent: Agent.optional(), + model: z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:/@[\]-]{0,127}$/).optional().describe('Model id from list_models (default: the agent\'s own default).'), + effort: z.string().regex(/^[a-z]{2,16}$/).optional().describe('Effort level the model takes (list_models); needs `model`.'), + name: z.string().trim().min(1).max(100).optional().describe('Session (tab) title.'), + message: z.string().min(1).max(32_000).optional().describe('First prompt. Without it the agent starts idle.'), + attachments: z.array(Id('attachment')).min(1).max(10).optional().describe('Attachment ids from upload_attachment; needs `message`.') + }) + .strict(), + annotations: { title: 'Start agent session', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }, + run: async ({ workspaceId, ...body }, api) => fromApi(await api('POST', `/v1/workspaces/${workspaceId}/sessions`, body)) + }), + tool({ + name: 'cancel_session', + description: "Stops an agent's current turn in a session (like pressing Escape) and drops any of that session's messages still queued. The session stays open for the next send_message.", + input: z.object({ workspaceId: Id('workspace'), session: SessionHandle }).strict(), + annotations: { title: 'Cancel agent turn', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }, + run: async (args, api) => fromApi(await api('POST', `/v1/workspaces/${args.workspaceId}/sessions/${args.session}/cancel`)) + }), + tool({ + name: 'rename_session', + description: 'Renames an agent session (the tab title the desktop and phone show). The workspace must be running.', + input: z.object({ workspaceId: Id('workspace'), session: SessionHandle, name: z.string().trim().min(1).max(100).describe('New title.') }).strict(), + annotations: { title: 'Rename agent session', readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }, + run: async (args, api) => fromApi(await api('POST', `/v1/workspaces/${args.workspaceId}/sessions/${args.session}/rename`, { name: args.name })) + }), + tool({ + name: 'upload_attachment', + description: + 'Uploads a file (base64, up to 5 MB) to a workspace for an agent to read, e.g. a screenshot or log. Returns an attachment id; pass it in `attachments` to send_message or create_session and the agent is told where the file is. The file sits outside the repo, so it is never committed.', + input: z + .object({ + workspaceId: Id('workspace'), + filename: z.string().min(1).max(255).describe('File name, e.g. bug.png.'), + contentType: z.string().max(127).optional().describe('MIME type, e.g. image/png.'), + data: z.string().min(1).describe('The file bytes, base64-encoded.') + }) + .strict(), + annotations: { title: 'Upload attachment', readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }, + run: async ({ workspaceId, ...body }, api) => fromApi(await api('POST', `/v1/workspaces/${workspaceId}/attachments`, body)) + }), tool({ name: 'send_message', description: @@ -191,6 +261,7 @@ export const TOOLS = [ text: z.string().min(1).max(32_000).describe('The message or task for the agent.'), agent: Agent.optional(), session: z.string().regex(/^term_[A-Za-z0-9-]{1,80}$/).optional().describe('Session handle to continue (from list_sessions or a previous message).'), + attachments: z.array(Id('attachment')).min(1).max(10).optional().describe('Attachment ids from upload_attachment.'), waitSeconds: z.number().int().min(0).max(MAX_WAIT_SECONDS).optional().describe(`How long to wait for delivery (0-${MAX_WAIT_SECONDS}, default 20).`) }) .strict(), @@ -199,7 +270,8 @@ export const TOOLS = [ const response = await api('POST', `/v1/workspaces/${args.workspaceId}/messages`, { text: args.text, ...(args.agent ? { agent: args.agent } : {}), - ...(args.session ? { session: args.session } : {}) + ...(args.session ? { session: args.session } : {}), + ...(args.attachments ? { attachments: args.attachments } : {}) }) if (!response.ok) { return fromApi(response) diff --git a/cloud/apps/sandbox-control/src/member-removal.ts b/cloud/apps/sandbox-control/src/member-removal.ts index d63234aa1ff..ec1c42ddbc6 100644 --- a/cloud/apps/sandbox-control/src/member-removal.ts +++ b/cloud/apps/sandbox-control/src/member-removal.ts @@ -8,6 +8,7 @@ import type { LifecycleDeps } from './lifecycle' import { memberChangeTime, recordMemberChange } from './member-changes' import { revokeMemberReaderKeys } from './read-snapshots' import { disableMemberRoutines } from './routines/runs' +import { forgetMemberPokes } from './team-presence' export type MemberRemoval = { keysRevoked: number @@ -41,6 +42,8 @@ export async function removeMember( const devicesRevoked = await revokeMemberDeviceSessions(life.db, accountId, userId, now) // No device of theirs can open a sleeping workspace's read snapshot again (wrapped keys deleted). const readerKeysRevoked = await revokeMemberReaderKeys(life.db, accountId, userId, now) + // Their Pokes opt-in goes (it doubles as proof of membership for receiving one). + await forgetMemberPokes(life.db, accountId, userId, now) const grants = await revokeGrantsForMember(life, accountId, userId) // Routines run with their creator's secrets: a departed member's stop, and nothing of theirs keeps running. const routines = await disableMemberRoutines({ life }, accountId, userId) diff --git a/cloud/apps/sandbox-control/src/member-usage.ts b/cloud/apps/sandbox-control/src/member-usage.ts new file mode 100644 index 00000000000..d030fad3956 --- /dev/null +++ b/cloud/apps/sandbox-control/src/member-usage.ts @@ -0,0 +1,26 @@ +// Model spend by member and UTC hour, for teammate profiles' heatmap (team-presence.ts). The +// workspace registry keeps only a cumulative per-workspace total; this dates each increase and +// credits whoever's client reported it. +const HOUR_MS = 3_600_000 + +/** Records the reporter's new model spend: the growth of a workspace's cumulative token total. */ +export async function recordTokenSpend( + db: D1Database, + accountId: string, + userId: string, + previousUsdMicros: number | null, + nextUsdMicros: number, + now: number +): Promise { + const delta = nextUsdMicros - (previousUsdMicros ?? 0) + if (delta <= 0) { + return + } + await db + .prepare( + `INSERT INTO member_usage_hours (account_id, user_id, hour, token_usd_micros) VALUES (?, ?, ?, ?) + ON CONFLICT (account_id, user_id, hour) DO UPDATE SET token_usd_micros = token_usd_micros + excluded.token_usd_micros` + ) + .bind(accountId, userId, Math.floor(now / HOUR_MS), delta) + .run() +} diff --git a/cloud/apps/sandbox-control/src/org-slugs.ts b/cloud/apps/sandbox-control/src/org-slugs.ts new file mode 100644 index 00000000000..dfbc9191883 --- /dev/null +++ b/cloud/apps/sandbox-control/src/org-slugs.ts @@ -0,0 +1,123 @@ +// Org URL slugs for workspace links (orca://cloud//W-123). +// GET /v1/team/org?name= -> {slug, orgId}; the first call names it from `name` +// PUT /v1/team/org {slug} org owner/admin renames it (409 when another org has it) +// Auth owns orgs and knows their names; this Worker only sees ids. So the first member to ask +// proposes a slug from the name their client shows, and the Worker makes it unique. Personal +// accounts have no slug: their links keep the sandbox id form (orca://cloud/w/). +import { z } from 'zod' +import type { SandboxCaller } from './auth' +import { WorkspaceError, isOrgAdmin } from './workspaces' + +/** Path words a slug can't take: they'd read as a different link form. */ +const RESERVED = new Set(['w', 'c', 'me', 'api', 'app', 'new', 'org', 'team', 'settings', 'cloud', 'orca', 'admin', 'help', 'setup']) + +export const SLUG = /^[a-z0-9](?:[a-z0-9-]{0,38}[a-z0-9])?$/ + +export function isValidSlug(value: string): boolean { + return SLUG.test(value) && !value.includes('--') && !RESERVED.has(value) +} + +/** "Acme Labs, Inc." → "acme-labs-inc"; falls back to "team" when nothing usable is left. */ +export function slugify(name: string): string { + const base = name + .normalize('NFKD') + .replace(/[̀-ͯ]/g, '') + .toLowerCase() + .replace(/[^a-z0-9]+/g, '-') + .replace(/^-+|-+$/g, '') + .slice(0, 32) + .replace(/-+$/g, '') + return base.length >= 2 && !RESERVED.has(base) ? base : base ? `${base}-team` : 'team' +} + +type Row = { account_id: string; slug: string } + +/** `org:abc` / `dev:org:abc` → `abc` (the id the desktop's org list uses). */ +export function orgIdOf(accountId: string): string | null { + const match = /^(?:dev:)?org:(.+)$/.exec(accountId) + return match ? match[1]! : null +} + +export async function slugForAccount(db: D1Database, accountId: string): Promise { + const row = await db.prepare('SELECT slug FROM org_slugs WHERE account_id = ?').bind(accountId).first<{ slug: string }>() + return row?.slug ?? null +} + +export async function accountForSlug(db: D1Database, slug: string): Promise { + if (!isValidSlug(slug)) { + return null + } + const row = await db.prepare('SELECT account_id FROM org_slugs WHERE slug = ?').bind(slug).first() + return row?.account_id ?? null +} + +const NameQuery = z.string().trim().min(1).max(120) + +export async function getOrgSlug(db: D1Database, caller: SandboxCaller, url: URL, now: number) { + const orgId = caller.orgId ? orgIdOf(caller.accountId) : null + if (!orgId) { + return { slug: null, orgId: null } + } + const existing = await slugForAccount(db, caller.accountId) + if (existing) { + return { slug: existing, orgId } + } + const name = NameQuery.safeParse(url.searchParams.get('name') ?? '') + if (!name.success) { + // Nothing to name it from yet; the next client that knows the org's name will. + return { slug: null, orgId } + } + const base = slugify(name.data) + for (let attempt = 0; attempt < 20; attempt += 1) { + const candidate = attempt === 0 ? base : `${base.slice(0, 32)}-${attempt + 1}` + const result = await db + .prepare('INSERT OR IGNORE INTO org_slugs (account_id, slug, created_at, created_by, updated_at) VALUES (?, ?, ?, ?, ?)') + .bind(caller.accountId, candidate, now, caller.userId, now) + .run() + if (result.meta.changes === 1) { + return { slug: candidate, orgId } + } + // Either another org holds this slug, or a teammate just named ours (then use theirs). + const raced = await slugForAccount(db, caller.accountId) + if (raced) { + return { slug: raced, orgId } + } + } + throw new WorkspaceError('conflict', 'slug_exhausted') +} + +const PutSchema = z.object({ slug: z.string().min(1).max(40) }).strict() + +export async function putOrgSlug(db: D1Database, caller: SandboxCaller, body: unknown, now: number) { + const orgId = caller.orgId ? orgIdOf(caller.accountId) : null + if (!orgId) { + throw new WorkspaceError('invalid_request', 'personal_account') + } + if (!isOrgAdmin(caller)) { + throw new WorkspaceError('forbidden', 'admin_only') + } + const parsed = PutSchema.safeParse(body) + if (!parsed.success || !isValidSlug(parsed.data.slug)) { + throw new WorkspaceError('invalid_request', 'invalid_slug') + } + const slug = parsed.data.slug + const holder = await accountForSlug(db, slug) + if (holder && holder !== caller.accountId) { + throw new WorkspaceError('conflict', 'slug_taken') + } + await db + .prepare( + `INSERT INTO org_slugs (account_id, slug, created_at, created_by, updated_at) VALUES (?, ?, ?, ?, ?) + ON CONFLICT (account_id) DO UPDATE SET slug = excluded.slug, updated_at = excluded.updated_at` + ) + .bind(caller.accountId, slug, now, caller.userId, now) + .run() + .catch((error: unknown) => { + // The UNIQUE index lost a race with another org claiming the same slug. + if (String(error).includes('UNIQUE')) { + throw new WorkspaceError('conflict', 'slug_taken') + } + throw error + }) + return { slug, orgId } +} diff --git a/cloud/apps/sandbox-control/src/sandbox-provider.ts b/cloud/apps/sandbox-control/src/sandbox-provider.ts index 9f9852141d6..8eba9363a31 100644 --- a/cloud/apps/sandbox-control/src/sandbox-provider.ts +++ b/cloud/apps/sandbox-control/src/sandbox-provider.ts @@ -111,6 +111,11 @@ export type SandboxProviderApi = { updateSnapshotExpiration(name: string, expirationMs: number): Promise /** A small text file from the VM (files API: not kept as command logs). Null when absent. */ readFile(sessionId: string, path: string): Promise + /** + * Writes one file (absolute path, parents created) into a running session through the files API, + * so the bytes never pass through argv, env or command logs. Optional: only API attachments use it. + */ + writeFile?(sessionId: string, path: string, bytes: Uint8Array): Promise /** Resolves when already gone. */ deleteSandbox(name: string): Promise listSnapshots(name: string): Promise diff --git a/cloud/apps/sandbox-control/src/sandbox-vm-commands.ts b/cloud/apps/sandbox-control/src/sandbox-vm-commands.ts index 3e54d4266b6..0cb3c5c5c82 100644 --- a/cloud/apps/sandbox-control/src/sandbox-vm-commands.ts +++ b/cloud/apps/sandbox-control/src/sandbox-vm-commands.ts @@ -49,8 +49,33 @@ export type StartInputs = { prelude?: { script: string; env?: Record } /** This session's share-proxy key (src/share-crypto.ts); the proxy keeps it in memory only. */ shareProxyKey?: string + /** + * The VM's hostname for this boot (workspaceHostname): terminal prompts read `ubuntu@` + * instead of the provider's VM id, which changes on every wake (JA-27). Set before orcad starts, so + * every shell it opens sees it. Best effort: a failure keeps the provider's name. + */ + hostname?: string } +/** A hostname label from a workspace name: lowercase letters, digits and dashes, at most 63 chars. */ +export function workspaceHostname(name: string | null | undefined): string | undefined { + const label = (name ?? '') + .toLowerCase() + .replace(/[^a-z0-9-]+/g, '-') + .replace(/-+/g, '-') + .replace(/^-+/, '') + .slice(0, 63) + .replace(/-+$/, '') + return label.length > 0 ? label : undefined +} + +// Inline per boot, no image change: hostname plus an /etc/hosts entry (sudo would warn without one). +const HOSTNAME_STEP = [ + '{ [ -n "${ORCA_HOSTNAME:-}" ] && sudo -n hostname "$ORCA_HOSTNAME" &&', + '{ grep -q "[[:space:]]$ORCA_HOSTNAME\\$" /etc/hosts || printf "127.0.1.1 %s\\n" "$ORCA_HOSTNAME" | sudo -n tee -a /etc/hosts; }; }', + '>/dev/null 2>&1 || true; unset ORCA_HOSTNAME' +].join(' ') + /** `NAME=` lines, so values with newlines or quotes survive bash intact. */ export function encodeSecretEnv(env: Record): string { return Object.entries(env) @@ -100,6 +125,10 @@ export async function startOrcad( if (inputs.shareProxyKey) { env.ORCA_SHARE_PROXY_KEY = inputs.shareProxyKey } + if (inputs.hostname) { + env.ORCA_HOSTNAME = inputs.hostname + } + const hostnameStep = inputs.hostname ? `${HOSTNAME_STEP}; ` : '' // The prelude rides in an env var (the start script's `env -i` keeps it out of orcad) so one // round trip both prepares the checkout and starts orcad. const result = await provider.runCommand( @@ -108,11 +137,16 @@ export async function startOrcad( ? { command: 'bash', // The prelude never sees the share-proxy or ready keys; only the start script gets them. - args: ['-c', `env -u ORCA_SHARE_PROXY_KEY -u ORCA_READY_KEY bash -c "$ORCA_PRELUDE" 1>&2 || true; unset ORCA_PRELUDE; exec ${START_COMMAND}`], + args: [ + '-c', + `${hostnameStep}env -u ORCA_SHARE_PROXY_KEY -u ORCA_READY_KEY bash -c "$ORCA_PRELUDE" 1>&2 || true; unset ORCA_PRELUDE; exec ${START_COMMAND}` + ], env: { ...env, ...inputs.prelude.env, ORCA_PRELUDE: inputs.prelude.script }, timeoutMs: START_TIMEOUT_MS } - : { command: START_COMMAND, env, timeoutMs: START_TIMEOUT_MS } + : hostnameStep + ? { command: 'bash', args: ['-c', `${hostnameStep}exec ${START_COMMAND}`], env, timeoutMs: START_TIMEOUT_MS } + : { command: START_COMMAND, env, timeoutMs: START_TIMEOUT_MS } ) if (result.exitCode !== 0) { throw new VmCommandError('orcad_start_failed') diff --git a/cloud/apps/sandbox-control/src/store.ts b/cloud/apps/sandbox-control/src/store.ts index 14ec858457b..64a5c48b88a 100644 --- a/cloud/apps/sandbox-control/src/store.ts +++ b/cloud/apps/sandbox-control/src/store.ts @@ -71,6 +71,8 @@ export type SandboxRow = { last_activity_at: number | null last_activity_by: string | null token_usd_micros: number | null + /** 0051: this workspace's number in its account (shown as W-123); null only on rows from before it. */ + number?: number | null } export type WorkspaceVisibility = 'private' | 'team' @@ -118,18 +120,28 @@ export async function insertSandbox( Partial>, now: number ): Promise { - await db - .prepare( - `INSERT INTO sandboxes (id, account_id, user_id, workspace_id, provider, provider_name, status, - machine_size, region, generation, created_at, updated_at, repo_url, environment_id, environment_build_id, - source_snapshot_id, created_by, name, repo_branch, visibility, section, last_activity_at, last_activity_by) - VALUES (?, ?, ?, ?, ?, ?, 'creating', ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` - ) - .bind(row.id, row.account_id, row.user_id, row.workspace_id, row.provider, row.provider_name, - row.machine_size, row.region, now, now, row.repo_url, row.environment_id ?? null, - row.environment_build_id ?? null, row.source_snapshot_id ?? null, row.user_id, row.name ?? null, - row.repo_branch ?? null, row.visibility ?? 'private', row.section ?? null, now, row.user_id) - .run() + // One transaction: bump the account's counter, then take its value as this row's number (W-123). + // A failed insert rolls the bump back; a destroyed row keeps its number, so none is ever reused. + await db.batch([ + db + .prepare( + `INSERT INTO org_workspace_counters (account_id, last_number) VALUES (?, 1) + ON CONFLICT (account_id) DO UPDATE SET last_number = last_number + 1` + ) + .bind(row.account_id), + db + .prepare( + `INSERT INTO sandboxes (id, account_id, user_id, workspace_id, provider, provider_name, status, + machine_size, region, generation, created_at, updated_at, repo_url, environment_id, environment_build_id, + source_snapshot_id, created_by, name, repo_branch, visibility, section, last_activity_at, last_activity_by, number) + VALUES (?, ?, ?, ?, ?, ?, 'creating', ?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, + (SELECT last_number FROM org_workspace_counters WHERE account_id = ?))` + ) + .bind(row.id, row.account_id, row.user_id, row.workspace_id, row.provider, row.provider_name, + row.machine_size, row.region, now, now, row.repo_url, row.environment_id ?? null, + row.environment_build_id ?? null, row.source_snapshot_id ?? null, row.user_id, row.name ?? null, + row.repo_branch ?? null, row.visibility ?? 'private', row.section ?? null, now, row.user_id, row.account_id) + ]) const inserted = await getSandbox(db, row.id) if (!inserted) { throw new Error('sandbox insert lost') diff --git a/cloud/apps/sandbox-control/src/tar-gzip.ts b/cloud/apps/sandbox-control/src/tar-gzip.ts new file mode 100644 index 00000000000..c9ff3a940b7 --- /dev/null +++ b/cloud/apps/sandbox-control/src/tar-gzip.ts @@ -0,0 +1,68 @@ +// Minimal ustar writer for the Vercel files API (POST .../fs/write takes a gzipped tarball, the same +// format @vercel/sandbox's FileWriter streams). Workers have no tar library; one regular file plus +// its parent directories is all the control plane ever writes. + +const BLOCK = 512 + +function octal(value: number, width: number): string { + // width includes the trailing NUL. + return value.toString(8).padStart(width - 1, '0') +} + +function header(path: string, entry: { type: 'file' | 'dir'; size: number; mode: number; mtime: number }): Uint8Array { + const block = new Uint8Array(BLOCK) + const encoder = new TextEncoder() + const put = (offset: number, text: string, width: number) => { + const bytes = encoder.encode(text) + if (bytes.length > width) { + throw new Error('tar_field_too_long') + } + block.set(bytes, offset) + } + // Long paths split at a slash: prefix (155) + "/" + name (100). + let name = path + let prefix = '' + if (encoder.encode(path).length > 100) { + const cut = path.lastIndexOf('/', path.length - 2) + if (cut <= 0) { + throw new Error('tar_name_too_long') + } + prefix = path.slice(0, cut) + name = path.slice(cut + 1) + } + put(0, name, 100) + put(100, octal(entry.mode, 8), 8) + put(108, octal(0, 8), 8) + put(116, octal(0, 8), 8) + put(124, octal(entry.size, 12), 12) + put(136, octal(Math.floor(entry.mtime / 1000), 12), 12) + block.fill(0x20, 148, 156) // checksum field counts as spaces while summing + put(156, entry.type === 'dir' ? '5' : '0', 1) + put(257, 'ustar\u000000', 8) + put(345, prefix, 155) + const sum = block.reduce((total, byte) => total + byte, 0) + put(148, `${octal(sum, 7)}\u0000 `, 8) + return block +} + +/** + * A gzipped tarball holding `dirs` (created first, mode 0755) and one file at `path` (0644). Paths + * are relative to the extraction directory and must not contain `..` segments. + */ +export async function tarGzipFile(input: { dirs: string[]; path: string; bytes: Uint8Array; mtime: number }): Promise { + for (const p of [...input.dirs, input.path]) { + if (p.startsWith('/') || p.split('/').some((segment) => segment === '..' || segment === '')) { + throw new Error('tar_bad_path') + } + } + const padding = (BLOCK - (input.bytes.length % BLOCK)) % BLOCK + const parts: Uint8Array[] = [ + ...input.dirs.map((dir) => header(`${dir}/`, { type: 'dir', size: 0, mode: 0o755, mtime: input.mtime })), + header(input.path, { type: 'file', size: input.bytes.length, mode: 0o644, mtime: input.mtime }), + input.bytes, + new Uint8Array(padding), + new Uint8Array(BLOCK * 2) // end-of-archive marker + ] + const stream = new Blob(parts as BlobPart[]).stream().pipeThrough(new CompressionStream('gzip')) + return new Response(stream).arrayBuffer() +} diff --git a/cloud/apps/sandbox-control/src/team-presence.ts b/cloud/apps/sandbox-control/src/team-presence.ts new file mode 100644 index 00000000000..621b21e8911 --- /dev/null +++ b/cloud/apps/sandbox-control/src/team-presence.ts @@ -0,0 +1,350 @@ +// Teammate profiles and Pokes (Conductor 0.91 parity). +// GET /v1/team/members/:userId/profile?utcOffsetMin=<-840..840> +// POST /v1/team/members/:userId/poke +// GET /v1/team/pokes the caller's unseen pokes (last 24 h) and their opt-in +// PUT /v1/team/pokes/settings {enabled} +// POST /v1/team/pokes/seen {ids} +// Privacy: a profile shows what a teammate can already see (name, role from the roster, workspaces +// they can open). The 0–4 intensity per day is shared only by people who turned on "Pokes and +// activity" (the same opt-in as Pokes); exact amounts only ever go to the person themself. The +// heatmap counts the member's sandbox time (usage_outbox, attributed to the workspace owner) plus +// model spend their own client reported (member_usage_hours). +import { z } from 'zod' +import type { SandboxCaller } from './auth' +import { memberNamesFor } from './member-names' +import type { SandboxRow } from './store' +import { canSee, COMPUTE_USD_MICROS_PER_HOUR, workspaceViews } from './workspaces' +import { + POKE_INBOX_TTL_MS, + POKE_PAIR_COOLDOWN_MS, + POKE_SENDER_HOURLY_LIMIT, + TEAMMATE_HEATMAP_DAYS, + TEAMMATE_RECENT_WORKSPACES, + type PokeRefusal +} from '../../../../src/shared/cloud-workspaces/team-presence-wire' + +const DAY_MS = 86_400_000 +const HOUR_MS = 3_600_000 + +export class TeamPresenceError extends Error { + constructor( + readonly status: number, + readonly code: string, + readonly reason?: PokeRefusal | string, + readonly retryAfterMs?: number + ) { + super(reason ? `${code}:${reason}` : code) + this.name = 'TeamPresenceError' + } +} + +export const MEMBER_ID = /^[A-Za-z0-9_.:-]{1,128}$/ + +function isoDate(dayIndex: number): string { + return new Date(dayIndex * DAY_MS).toISOString().slice(0, 10) +} + +/** 0 for nothing; otherwise 1–4 relative to the member's own busiest day in the window. */ +export function usageLevel(value: number, max: number): number { + if (value <= 0 || max <= 0) { + return 0 + } + return Math.min(4, Math.max(1, Math.ceil((value / max) * 4))) +} + +/** + * Per local day: sandbox time on workspaces the member owns, and model spend they reported. Days + * are the viewer's calendar days (utcOffsetMin); a segment crossing midnight is split. + */ +export async function memberDailyUsage( + db: D1Database, + accountId: string, + userId: string, + now: number, + utcOffsetMin: number, + days = TEAMMATE_HEATMAP_DAYS +) { + const offsetMs = utcOffsetMin * 60_000 + const today = Math.floor((now + offsetMs) / DAY_MS) + const firstDay = today - days + 1 + const windowStart = firstDay * DAY_MS - offsetMs + const computeMs = new Array(days).fill(0) + const tokenUsd = new Array(days).fill(0) + const { results: segments } = await db + .prepare( + `SELECT u.started_at, u.ended_at FROM usage_outbox u JOIN sandboxes s ON s.id = u.sandbox_id + WHERE u.account_id = ? AND u.started_at < ? AND u.ended_at > ? AND s.user_id = ?` + ) + .bind(accountId, now, windowStart, userId) + .all<{ started_at: number; ended_at: number }>() + for (const seg of segments) { + let from = Math.max(seg.started_at, windowStart) + const to = Math.min(seg.ended_at, now) + while (from < to) { + const day = Math.floor((from + offsetMs) / DAY_MS) + const dayEnd = (day + 1) * DAY_MS - offsetMs + const end = Math.min(to, dayEnd) + const index = day - firstDay + if (index >= 0 && index < days) { + computeMs[index]! += end - from + } + from = end + } + } + const { results: hours } = await db + .prepare( + `SELECT hour, token_usd_micros FROM member_usage_hours WHERE account_id = ? AND user_id = ? AND hour >= ?` + ) + .bind(accountId, userId, Math.floor(windowStart / HOUR_MS)) + .all<{ hour: number; token_usd_micros: number }>() + for (const row of hours) { + const index = Math.floor((row.hour * HOUR_MS + offsetMs) / DAY_MS) - firstDay + if (index >= 0 && index < days) { + tokenUsd[index]! += row.token_usd_micros + } + } + const rate = COMPUTE_USD_MICROS_PER_HOUR.standard + const usdMicros = computeMs.map((ms, i) => Math.round((ms / HOUR_MS) * rate) + tokenUsd[i]!) + const max = Math.max(0, ...usdMicros) + return { + start: isoDate(firstDay), + levels: usdMicros.map((value) => usageLevel(value, max)), + activeDays: usdMicros.filter((value) => value > 0).length, + computeMs, + usdMicros + } +} + +async function pokesEnabled(db: D1Database, accountId: string, userId: string): Promise { + const row = await db + .prepare('SELECT enabled FROM member_poke_prefs WHERE account_id = ? AND user_id = ?') + .bind(accountId, userId) + .first<{ enabled: number }>() + return row?.enabled === 1 +} + +function requireTeam(caller: SandboxCaller): void { + if (!caller.orgId) { + throw new TeamPresenceError(400, 'invalid_request', 'personal_account') + } +} + +export type ActivitySharing = 'opt_in' | 'team' + +export async function memberProfile( + db: D1Database, + caller: SandboxCaller, + userId: string, + url: URL, + now: number, + activitySharing: ActivitySharing = 'opt_in' +) { + const self = userId === caller.userId + if (!self && !caller.orgId) { + // A personal account has no teammates. + throw new TeamPresenceError(404, 'not_found') + } + const offset = Number(url.searchParams.get('utcOffsetMin') ?? '0') + const utcOffsetMin = Number.isInteger(offset) && Math.abs(offset) <= 14 * 60 ? offset : 0 + const { results } = await db + .prepare( + `SELECT * FROM sandboxes WHERE account_id = ? AND status <> 'destroyed' AND archived_at IS NULL + AND (user_id = ? OR created_by = ?) ORDER BY COALESCE(last_activity_at, updated_at) DESC LIMIT 100` + ) + .bind(caller.accountId, userId, userId) + .all() + // Only workspaces the viewer could already open from Home: a teammate's private ones stay private. + const rows = results.filter((row) => !row.hidden && canSee(caller, row)).slice(0, TEAMMATE_RECENT_WORKSPACES) + const [names, recentWorkspaces, mine, theirs] = await Promise.all([ + memberNamesFor(db, caller.accountId, [userId]), + workspaceViews(db, caller, rows, now), + caller.orgId ? pokesEnabled(db, caller.accountId, caller.userId) : Promise.resolve(false), + caller.orgId && !self ? pokesEnabled(db, caller.accountId, userId) : Promise.resolve(false) + ]) + // Your own heatmap always; a teammate's only when they chose to share it. + const usage = self || theirs || activitySharing === 'team' ? await memberDailyUsage(db, caller.accountId, userId, now, utcOffsetMin) : null + return { + profile: { + userId, + self, + name: names.get(userId) ?? null, + usage: usage && { + start: usage.start, + levels: usage.levels, + activeDays: usage.activeDays, + own: self ? { computeMs: usage.computeMs, usdMicros: usage.usdMicros } : null + }, + recentWorkspaces, + pokes: { enabled: mine, teammateEnabled: self ? null : theirs } + } + } +} + +export const PokeSettingsBody = z.object({ enabled: z.boolean() }).strict() +export const PokesSeenBody = z.object({ ids: z.array(z.string().regex(/^pok_[0-9a-f]{24}$/)).min(1).max(50) }).strict() + +export async function setPokeSettings(db: D1Database, caller: SandboxCaller, enabled: boolean, now: number) { + requireTeam(caller) + const statements = [ + db + .prepare( + `INSERT INTO member_poke_prefs (account_id, user_id, enabled, updated_at) VALUES (?, ?, ?, ?) + ON CONFLICT (account_id, user_id) DO UPDATE SET enabled = excluded.enabled, updated_at = excluded.updated_at` + ) + .bind(caller.accountId, caller.userId, enabled ? 1 : 0, now) + ] + if (!enabled) { + // Turning it off drops anything waiting, so turning it back on doesn't replay old pokes. + statements.push( + db + .prepare('UPDATE member_pokes SET seen_at = ? WHERE account_id = ? AND to_user_id = ? AND seen_at IS NULL') + .bind(now, caller.accountId, caller.userId) + ) + } + await db.batch(statements) + return { enabled } +} + +export async function pokeInbox(db: D1Database, caller: SandboxCaller, now: number) { + if (!caller.orgId) { + return { enabled: false, pokes: [] } + } + const enabled = await pokesEnabled(db, caller.accountId, caller.userId) + if (!enabled) { + return { enabled, pokes: [] } + } + const { results } = await db + .prepare( + `SELECT id, from_user_id, created_at FROM member_pokes + WHERE account_id = ? AND to_user_id = ? AND seen_at IS NULL AND created_at > ? + ORDER BY created_at DESC LIMIT 20` + ) + .bind(caller.accountId, caller.userId, now - POKE_INBOX_TTL_MS) + .all<{ id: string; from_user_id: string; created_at: number }>() + const names = await memberNamesFor(db, caller.accountId, results.map((r) => r.from_user_id)) + return { + enabled, + pokes: results.map((r) => ({ id: r.id, fromUserId: r.from_user_id, fromName: names.get(r.from_user_id) ?? null, at: r.created_at })) + } +} + +export async function markPokesSeen(db: D1Database, caller: SandboxCaller, ids: readonly string[], now: number) { + await db + .prepare( + `UPDATE member_pokes SET seen_at = ? WHERE account_id = ? AND to_user_id = ? AND seen_at IS NULL + AND id IN (${ids.map(() => '?').join(', ')})` + ) + .bind(now, caller.accountId, caller.userId, ...ids) + .run() + return { ok: true as const } +} + +function pokeId(): string { + const bytes = crypto.getRandomValues(new Uint8Array(12)) + return `pok_${[...bytes].map((b) => b.toString(16).padStart(2, '0')).join('')}` +} + +/** + * Both people must have Pokes on. The teammate's own opt-in (written with their token in this + * account, and dropped when they leave it) is also what proves they are a member. + */ +export async function sendPoke(db: D1Database, caller: SandboxCaller, toUserId: string, now: number) { + requireTeam(caller) + if (toUserId === caller.userId) { + throw new TeamPresenceError(400, 'invalid_request', 'self') + } + if (!(await pokesEnabled(db, caller.accountId, caller.userId))) { + throw new TeamPresenceError(409, 'conflict', 'pokes_off') + } + if (!(await pokesEnabled(db, caller.accountId, toUserId))) { + throw new TeamPresenceError(409, 'conflict', 'teammate_pokes_off') + } + const recent = await db + .prepare( + `SELECT COUNT(*) AS sent, MAX(CASE WHEN to_user_id = ? THEN created_at END) AS last_to_them + FROM member_pokes WHERE account_id = ? AND from_user_id = ? AND created_at > ?` + ) + .bind(toUserId, caller.accountId, caller.userId, now - HOUR_MS) + .first<{ sent: number; last_to_them: number | null }>() + const lastToThem = recent?.last_to_them ?? null + if (lastToThem !== null && now - lastToThem < POKE_PAIR_COOLDOWN_MS) { + throw new TeamPresenceError(429, 'rate_limited', 'poke_cooldown', POKE_PAIR_COOLDOWN_MS - (now - lastToThem)) + } + if ((recent?.sent ?? 0) >= POKE_SENDER_HOURLY_LIMIT) { + throw new TeamPresenceError(429, 'rate_limited', 'poke_rate', HOUR_MS) + } + const id = pokeId() + await db.batch([ + db + .prepare('INSERT INTO member_pokes (id, account_id, from_user_id, to_user_id, created_at) VALUES (?, ?, ?, ?, ?)') + .bind(id, caller.accountId, caller.userId, toUserId, now), + // Keep the table small: nothing older than a day is ever read. + db.prepare('DELETE FROM member_pokes WHERE account_id = ? AND created_at < ?').bind(caller.accountId, now - 2 * POKE_INBOX_TTL_MS) + ]) + return { poke: { id, at: now } } +} + +/** A member left: their opt-in and anything waiting for them goes; pokes they sent stop showing. */ +export async function forgetMemberPokes(db: D1Database, accountId: string, userId: string, now: number): Promise { + await db.batch([ + db.prepare('DELETE FROM member_poke_prefs WHERE account_id = ? AND user_id = ?').bind(accountId, userId), + db + .prepare('UPDATE member_pokes SET seen_at = ? WHERE account_id = ? AND (to_user_id = ? OR from_user_id = ?) AND seen_at IS NULL') + .bind(now, accountId, userId, userId) + ]) +} + +/** Routes under /v1/team/members and /v1/team/pokes; null when the path isn't one of them. */ +export async function teamPresenceRoute( + db: D1Database, + caller: SandboxCaller, + request: Request, + url: URL, + now: number, + readJson: () => Promise, + options: { activitySharing?: ActivitySharing } = {} +): Promise { + const member = /^\/v1\/team\/members\/([^/]+)\/(profile|poke)$/.exec(url.pathname) + if (member) { + let userId: string + try { + userId = decodeURIComponent(member[1]!) + } catch { + throw new TeamPresenceError(400, 'invalid_request') + } + if (!MEMBER_ID.test(userId)) { + throw new TeamPresenceError(400, 'invalid_request') + } + if (member[2] === 'profile' && request.method === 'GET') { + return memberProfile(db, caller, userId, url, now, options.activitySharing) + } + if (member[2] === 'poke' && request.method === 'POST') { + return sendPoke(db, caller, userId, now) + } + return null + } + if (url.pathname === '/v1/team/pokes' && request.method === 'GET') { + return pokeInbox(db, caller, now) + } + if (url.pathname === '/v1/team/pokes/settings') { + if (request.method === 'GET') { + return { enabled: caller.orgId ? await pokesEnabled(db, caller.accountId, caller.userId) : false } + } + if (request.method === 'PUT') { + const body = PokeSettingsBody.safeParse(await readJson()) + if (!body.success) { + throw new TeamPresenceError(400, 'invalid_request') + } + return setPokeSettings(db, caller, body.data.enabled, now) + } + return null + } + if (url.pathname === '/v1/team/pokes/seen' && request.method === 'POST') { + const body = PokesSeenBody.safeParse(await readJson()) + if (!body.success) { + throw new TeamPresenceError(400, 'invalid_request') + } + return markPokesSeen(db, caller, body.data.ids, now) + } + return null +} diff --git a/cloud/apps/sandbox-control/src/vercel-sandbox-api.ts b/cloud/apps/sandbox-control/src/vercel-sandbox-api.ts index 088c66da934..c19cbcc76f7 100644 --- a/cloud/apps/sandbox-control/src/vercel-sandbox-api.ts +++ b/cloud/apps/sandbox-control/src/vercel-sandbox-api.ts @@ -3,6 +3,7 @@ import { z } from 'zod' import type { NetworkPolicy } from './network-policy' import type { GoldenImageProviderApi } from './golden-image-provider' +import { tarGzipFile } from './tar-gzip' import { ProviderError, type CommandResult, @@ -265,6 +266,27 @@ export function createVercelSandboxApi( } }, + async writeFile(sessionId, path, bytes) { + // Same call @vercel/sandbox's writeFiles makes: a gzipped tarball extracted at `/`. + const relative = path.replace(/^\/+/, '') + const segments = relative.split('/') + const dirs = segments.slice(0, -1).map((_, i) => segments.slice(0, i + 1).join('/')) + const body = await tarGzipFile({ dirs, path: relative, bytes, mtime: Date.now() }) + const url = new URL(`${base}/v2/sandboxes/sessions/${encodeURIComponent(sessionId)}/fs/write`) + url.searchParams.set('teamId', config.teamId) + const response = await doFetch(url, { + method: 'POST', + headers: { authorization: `Bearer ${config.token}`, 'content-type': 'application/gzip', 'x-cwd': '/' }, + body, + redirect: 'manual' + }) + if (!response.ok) { + const parsed = ErrorBody.safeParse(await response.json().catch(() => null)) + throw new ProviderError(response.status, parsed.success ? (parsed.data.error?.code ?? null) : null) + } + await response.body?.cancel() + }, + deleteSandbox: (name) => missingOk(() => request('DELETE', `/v2/sandboxes/${encodeURIComponent(name)}`, { diff --git a/cloud/apps/sandbox-control/src/wire.ts b/cloud/apps/sandbox-control/src/wire.ts index efc6303704a..5d91dffaea7 100644 --- a/cloud/apps/sandbox-control/src/wire.ts +++ b/cloud/apps/sandbox-control/src/wire.ts @@ -75,7 +75,13 @@ export function sandboxView(row: SandboxRow, archivedAware = false) { } } -export function readyView(row: SandboxRow, connection: OrcadReady, cloning = false) { +export function readyView( + row: SandboxRow, + connection: OrcadReady, + cloning?: 'clone' | 'update', + /** The client knows `mode` (feature `repo-update`); older ones show an update as a clone. */ + updateAware = false +) { return { sandbox: sandboxView(row), connection: { @@ -84,7 +90,9 @@ export function readyView(row: SandboxRow, connection: OrcadReady, cloning = fal projectRoot: connection.projectRoot }, // Only for a create that asked (feature `clone-progress`): the repo is still cloning. - ...(cloning ? { clone: { state: 'running' as const } } : {}) + ...(cloning + ? { clone: { state: 'running' as const, ...(cloning === 'update' && updateAware ? { mode: 'update' as const } : {}) } } + : {}) } } diff --git a/cloud/apps/sandbox-control/src/workspace-prefs.ts b/cloud/apps/sandbox-control/src/workspace-prefs.ts new file mode 100644 index 00000000000..49fca99c3d0 --- /dev/null +++ b/cloud/apps/sandbox-control/src/workspace-prefs.ts @@ -0,0 +1,86 @@ +// A member's own sidebar arrangement of cloud workspaces, stored on the account so every device +// (desktops and the phone) shows the same pins, order and sections. +// GET /v1/team/prefs -> {document, revision, updatedAt} +// PUT /v1/team/prefs {document, revision} `revision` is the one the client edited (compare-and-set: +// a stale write gets 409 and the client re-applies its edit) +// Per member, per account: switching teams switches arrangements. Ids that no longer exist are +// harmless (clients skip them) and are dropped the next time that client writes. +import { z } from 'zod' +import type { SandboxCaller } from './auth' +import { WorkspaceError } from './workspaces' + +const SandboxId = z.string().regex(/^sbx_[0-9a-f]{24}$/) +const SectionName = z.string().trim().min(1).max(64).regex(/^[^\u0000-\u001f]+$/) + +const unique = (list: readonly string[]) => new Set(list).size === list.length + +export const WorkspacePrefsDocumentSchema = z + .object({ + /** Pinned workspaces, top to bottom. */ + pinned: z.array(SandboxId).max(200).refine(unique, 'duplicate id'), + /** Manual order of the rest (drag to reorder); workspaces not listed follow, newest first. */ + order: z.array(SandboxId).max(500).refine(unique, 'duplicate id'), + /** Section order, including sections that are empty right now. */ + sections: z.array(SectionName).max(50).refine(unique, 'duplicate section'), + /** Sections this member keeps collapsed. */ + collapsed: z.array(SectionName).max(50).refine(unique, 'duplicate section') + }) + .strict() + .refine((doc) => !doc.pinned.some((id) => doc.order.includes(id)), 'pinned ids stay out of order') + +export type WorkspacePrefsDocument = z.infer + +const PutSchema = z + .object({ + document: WorkspacePrefsDocumentSchema, + revision: z.number().int().min(0), + /** Which device wrote it (a label for debugging sync, never trusted for access). */ + deviceId: z.string().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/).optional() + }) + .strict() + +export const EMPTY_PREFS: WorkspacePrefsDocument = { pinned: [], order: [], sections: [], collapsed: [] } + +type Row = { document: string; revision: number; updated_at: number } + +export async function getWorkspacePrefs(db: D1Database, caller: SandboxCaller) { + const row = await db + .prepare('SELECT document, revision, updated_at FROM workspace_prefs WHERE account_id = ? AND user_id = ?') + .bind(caller.accountId, caller.userId) + .first() + if (!row) { + return { document: EMPTY_PREFS, revision: 0, updatedAt: null } + } + // A document from a newer schema parses leniently: unknown keys are ignored, bad ones reset. + const parsed = WorkspacePrefsDocumentSchema.safeParse(JSON.parse(row.document)) + return { document: parsed.success ? parsed.data : EMPTY_PREFS, revision: row.revision, updatedAt: row.updated_at } +} + +export async function putWorkspacePrefs(db: D1Database, caller: SandboxCaller, body: unknown, now: number) { + const parsed = PutSchema.safeParse(body) + if (!parsed.success) { + throw new WorkspaceError('invalid_request') + } + const { document, revision, deviceId } = parsed.data + const text = JSON.stringify(document) + const result = + revision === 0 + ? await db + .prepare( + `INSERT OR IGNORE INTO workspace_prefs (account_id, user_id, document, revision, updated_at, updated_by_device) + VALUES (?, ?, ?, 1, ?, ?)` + ) + .bind(caller.accountId, caller.userId, text, now, deviceId ?? null) + .run() + : await db + .prepare( + `UPDATE workspace_prefs SET document = ?, revision = revision + 1, updated_at = ?, updated_by_device = ? + WHERE account_id = ? AND user_id = ? AND revision = ?` + ) + .bind(text, now, deviceId ?? null, caller.accountId, caller.userId, revision) + .run() + if (result.meta.changes !== 1) { + throw new WorkspaceError('conflict', 'stale_revision') + } + return getWorkspacePrefs(db, caller) +} diff --git a/cloud/apps/sandbox-control/src/workspaces.ts b/cloud/apps/sandbox-control/src/workspaces.ts index f29d0c52e5c..28664ab1184 100644 --- a/cloud/apps/sandbox-control/src/workspaces.ts +++ b/cloud/apps/sandbox-control/src/workspaces.ts @@ -1,10 +1,10 @@ // Team workspace registry: the cloud-owned list of an org's workspaces (who made it, who owns it, // repo/branch, state, last activity, visibility, section, cost) and who is in each one right now. -// GET /v1/team/workspaces?scope=mine|team|all&by=&repo=§ion=&archived=exclude|include|only +// GET /v1/team/workspaces?scope=mine|team|all&by=&repo=§ion=&archived=exclude|include|only&routines=exclude|include // GET /v1/team/workspaces/:id // PATCH /v1/team/workspaces/:id {title?, branch?, visibility?, section?, archived?, ownerUserId?, tokenUsdMicros?} // POST /v1/team/workspaces/:id/presence {clientId, state: viewing|typing|left, chatId?} -// GET /v1/team/links/resolve?w=&c= +// GET /v1/team/links/resolve?w=&c= or ?org=&n=&c= // Access rule: a workspace is visible to its owner, and to every member of the owning org when // visibility is `team`. Org owners/admins additionally see private rows' metadata (scope=all) so a // departed member's workspaces can be reassigned or archived — metadata only, never access. @@ -13,8 +13,10 @@ import type { SandboxCaller } from './auth' import type { MachineSize } from './entitlements' import { getSandbox, touchActivity, updateRegistry, type SandboxRow } from './store' import { memberNamesFor } from './member-names' +import { recordTokenSpend } from './member-usage' import { readSnapshotTimes } from './read-snapshots' import { sandboxView } from './wire' +import { accountForSlug, orgIdOf, slugForAccount } from './org-slugs' import { ORCA_CLOUD_OVERAGE_CENTS_PER_HOUR } from '../../../../src/shared/hosted-sandbox/hosted-sandbox-wire' export const PRESENCE_TTL_MS = 45_000 @@ -170,11 +172,12 @@ function repoView(row: SandboxRow) { export async function workspaceViews(db: D1Database, caller: SandboxCaller, rows: readonly SandboxRow[], now: number) { const ids = rows.map((r) => r.id) - const [presence, compute, granted, readAt] = await Promise.all([ + const [presence, compute, granted, readAt, slug] = await Promise.all([ presenceFor(db, ids, now), computeMsFor(db, ids), activeGrantUsers(db, ids, caller.userId), - readSnapshotTimes(db, ids) + readSnapshotTimes(db, ids), + rows.length > 0 ? slugForAccount(db, caller.accountId) : Promise.resolve(null) ]) const referenced = (row: SandboxRow, live: readonly PresenceRow[]) => [row.user_id, row.created_by, row.last_activity_by, ...live.map((p) => p.user_id)].filter( @@ -196,6 +199,10 @@ export async function workspaceViews(db: D1Database, caller: SandboxCaller, rows return { ...sandboxView(row), title: row.name, + // W-123 in its account; null only for a row that predates numbering and was never backfilled. + number: row.number ?? null, + // The link to copy: org slug + number when both exist, else the sandbox id form. + link: workspaceLink(row, slug), repo: repoView(row), visibility: row.visibility, section: row.section, @@ -210,7 +217,9 @@ export async function workspaceViews(db: D1Database, caller: SandboxCaller, rows // Display names (token `name` claim) for the ids above; the roster wins where it has one. memberNames, // When its sleeping read-only copy was saved ("As of"); only for those who may read it. - readSnapshotAt: canOpen(caller, row) ? (readAt.get(row.id) ?? null) : null + readSnapshotAt: canOpen(caller, row) ? (readAt.get(row.id) ?? null) : null, + // Started by a routine run (Home hides these unless its Routine runs filter is on). + fromRoutine: isRoutineRun(row) } }) } @@ -220,9 +229,16 @@ const ListQuery = z.object({ by: z.string().min(1).max(128).optional(), repo: z.string().min(1).max(2048).optional(), section: z.string().min(1).max(64).optional(), - archived: z.enum(['exclude', 'include', 'only']).default('exclude') + archived: z.enum(['exclude', 'include', 'only']).default('exclude'), + /** Routine runs stay off Home unless asked for (`include`), like Conductor's routine filter. */ + routines: z.enum(['exclude', 'include']).default('exclude') }) +/** A routine run's VM: tagged at create, and keyed `routine-…` while it boots. */ +export function isRoutineRun(row: SandboxRow): boolean { + return (row as { origin?: string | null }).origin === 'routine' || row.workspace_id.startsWith('routine-') +} + export async function listWorkspaces(db: D1Database, caller: SandboxCaller, url: URL, now: number) { const query = ListQuery.safeParse(Object.fromEntries(url.searchParams)) if (!query.success) { @@ -236,7 +252,7 @@ export async function listWorkspaces(db: D1Database, caller: SandboxCaller, url: .prepare(`SELECT * FROM sandboxes WHERE account_id = ? AND status <> 'destroyed' ORDER BY COALESCE(last_activity_at, updated_at) DESC LIMIT 500`) .bind(caller.accountId) .all() - const rows = results.filter((row) => { + const matching = results.filter((row) => { if (q.scope === 'mine' ? row.user_id !== caller.userId : q.scope === 'team' ? !canSee(caller, row) : false) { return false } @@ -246,7 +262,8 @@ export async function listWorkspaces(db: D1Database, caller: SandboxCaller, url: if (q.repo && row.repo_url !== q.repo) { return false } - if (row.hidden) { + // Hidden rows are machine-made: only routine runs ever come back (below), and only when asked for. + if (row.hidden && !isRoutineRun(row)) { return false } if (q.section && row.section !== q.section) { @@ -254,7 +271,47 @@ export async function listWorkspaces(db: D1Database, caller: SandboxCaller, url: } return q.archived === 'include' || (q.archived === 'only') === (row.archived_at !== null) }) - return { workspaces: await workspaceViews(db, caller, rows, now) } + const runs = matching.filter(isRoutineRun) + const rows = q.routines === 'include' ? matching : matching.filter((row) => !isRoutineRun(row)) + const hidden = q.routines === 'include' ? [] : runs + const [views, routineCount, hiddenCompute, routineNames] = await Promise.all([ + workspaceViews(db, caller, rows, now), + db.prepare('SELECT COUNT(*) AS n FROM routines WHERE account_id = ? AND deleted_at IS NULL').bind(caller.accountId).first<{ n: number }>(), + computeMsFor(db, hidden.map((row) => row.id)), + routineNamesFor(db, caller.accountId, rows.filter(isRoutineRun)) + ]) + return { + workspaces: views.map((view, i) => ({ ...view, routineName: routineNames.get(rows[i]!.id) ?? null })), + // Home: offer the Routine runs switch only when the team has routines, and say what it hides + // (its count and hours still belong in the team's totals). + routineRuns: { + routines: routineCount?.n ?? 0, + hidden: hidden.length, + hiddenRunning: hidden.filter((row) => row.status === 'running' || row.status === 'creating').length, + hiddenComputeMs: hidden.reduce((sum, row) => sum + costView(row, hiddenCompute.get(row.id) ?? 0, now).computeMs, 0) + } + } +} + +/** sandbox id -> its routine's name, for routine runs being listed. */ +async function routineNamesFor(db: D1Database, accountId: string, rows: readonly SandboxRow[]): Promise> { + const refs = [...new Set(rows.flatMap((row) => ((row as { origin_ref?: string | null }).origin_ref ? [(row as { origin_ref: string }).origin_ref] : [])))] + if (refs.length === 0) { + return new Map() + } + const { results } = await db + .prepare(`SELECT id, name FROM routines WHERE account_id = ? AND id IN (${refs.map(() => '?').join(', ')})`) + .bind(accountId, ...refs) + .all<{ id: string; name: string }>() + const byRoutine = new Map(results.map((r) => [r.id, r.name])) + const out = new Map() + for (const row of rows) { + const name = byRoutine.get((row as { origin_ref?: string | null }).origin_ref ?? '') + if (name) { + out.set(row.id, name) + } + } + return out } const SECTION = z.string().trim().min(1).max(64).regex(/^[^\u0000-\u001f]+$/) @@ -322,6 +379,12 @@ export async function patchWorkspace( if (!next) { throw new WorkspaceError('not_found') } + if (patch.tokenUsdMicros !== undefined) { + // Dated per reporter for teammate profiles' heatmap; the label above is only a running total. + await recordTokenSpend(db, row.account_id, caller.userId, row.token_usd_micros, patch.tokenUsdMicros, now).catch((error: unknown) => + console.warn('member_usage_write_failed', String(error)) + ) + } const ownerChanged = patch.ownerUserId !== undefined && patch.ownerUserId !== row.user_id const wentPrivate = row.visibility === 'team' && next.visibility === 'private' const archived = patch.archived === true && row.archived_at === null @@ -368,27 +431,56 @@ export async function reportPresence( return { presence: view!.presence } } -const LinkQuery = z.object({ - w: z.string().regex(/^sbx_[0-9a-f]{24}$/), - c: z.string().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/).optional() -}) +const ChatParam = z.string().min(1).max(128).regex(/^[A-Za-z0-9_.:-]+$/).optional() +const LinkQuery = z.union([ + z.object({ w: z.string().regex(/^sbx_[0-9a-f]{24}$/), c: ChatParam }), + z.object({ org: z.string().min(1).max(40), n: z.coerce.number().int().min(1).max(1e9), c: ChatParam }) +]) -/** orca://cloud/w/[/c/] → the workspace if the caller can see it; otherwise not_found. */ +/** A slug link that names a different org than the caller's current one. */ +export class LinkOtherOrgError extends WorkspaceError { + constructor(readonly orgId: string | null) { + super('not_found', 'other_org') + } +} + +/** + * orca://cloud/w/[/c/] or orca://cloud//W-[/c/] → the workspace if the caller + * can see it; otherwise not_found. A slug link for another org answers not_found with reason + * `other_org` and that org's id, so a client that belongs to it can offer to switch teams. + */ export async function resolveLink(db: D1Database, caller: SandboxCaller, url: URL, now: number) { const query = LinkQuery.safeParse(Object.fromEntries(url.searchParams)) if (!query.success) { throw new WorkspaceError('invalid_request') } - const row = await getSandbox(db, query.data.w) + const q = query.data + let row: SandboxRow | null + if ('w' in q) { + row = await getSandbox(db, q.w) + } else { + const accountId = await accountForSlug(db, q.org) + if (!accountId) { + throw new WorkspaceError('not_found') + } + if (accountId !== caller.accountId) { + throw new LinkOtherOrgError(orgIdOf(accountId)) + } + row = await db + .prepare('SELECT * FROM sandboxes WHERE account_id = ? AND number = ?') + .bind(accountId, q.n) + .first() + } if (!row || !canSee(caller, row)) { // Private, other org, or gone: the link reveals nothing about which. throw new WorkspaceError('not_found') } const [view] = await workspaceViews(db, caller, [row], now) - return { workspace: view, chatId: query.data.c ?? null } + return { workspace: view, chatId: q.c ?? null } } /** Canonical deep link for a workspace (and optionally a chat in it). */ -export function workspaceLink(id: string, chatId?: string): string { - return `orca://cloud/w/${id}${chatId ? `/c/${encodeURIComponent(chatId)}` : ''}` +export function workspaceLink(row: Pick, slug: string | null, chatId?: string): string { + const chat = chatId ? `/c/${encodeURIComponent(chatId)}` : '' + return slug && row.number ? `orca://cloud/${slug}/W-${row.number}${chat}` : `orca://cloud/w/${row.id}${chat}` } diff --git a/cloud/apps/sandbox-control/test/agent-accounts.test.ts b/cloud/apps/sandbox-control/test/agent-accounts.test.ts index 7adc26fb5d7..8a287fb8e50 100644 --- a/cloud/apps/sandbox-control/test/agent-accounts.test.ts +++ b/cloud/apps/sandbox-control/test/agent-accounts.test.ts @@ -334,3 +334,53 @@ describe('a provider 401 revokes only when confirmed', () => { expect(await auditRows()).toEqual([{ action: 'revoked', reason: 'provider_401_confirmed_by_check', upstream_path: '/v1/messages' }]) }) }) + +describe('POST /v1/agent-credentials/claude/verify (pre-launch check)', () => { + it('a pass is remembered: the next calls answer without asking the provider', async () => { + const { h, as, check } = await setup() + const mia = await as('mia') + await h.call('PUT', '/v1/agent-credentials/claude', { bearer: mia, body: { token: SETUP_TOKEN } }) + check.status = 200 + check.body = '{"input_tokens":3}' + const first = await h.call('POST', '/v1/agent-credentials/claude/verify', { bearer: mia }) + expect(first.body).toMatchObject({ claude: { state: 'active' }, checked: true }) + expect(first.body.verifiedAt).toEqual(expect.any(Number)) + const again = await h.call('POST', '/v1/agent-credentials/claude/verify', { bearer: mia }) + expect(again.body).toMatchObject({ claude: { state: 'active' }, checked: false, verifiedAt: first.body.verifiedAt }) + expect(check.calls).toBe(1) + }) + + it('a dead token is revoked (and audited); an inconclusive check keeps it', async () => { + const dead = await setup() + const mia = await dead.as('mia') + await dead.h.call('PUT', '/v1/agent-credentials/claude', { bearer: mia, body: { token: SETUP_TOKEN } }) + const revoked = await dead.h.call('POST', '/v1/agent-credentials/claude/verify', { bearer: mia }) + expect(revoked.body).toMatchObject({ claude: { state: 'revoked' }, checked: true, verifiedAt: null }) + const rows = (await dead.h.env.SANDBOX_DB.prepare('SELECT action, reason FROM agent_credential_audit').all()).results + expect(rows).toEqual([{ action: 'revoked', reason: 'verify_confirmed_auth_failure' }]) + + const flaky = await setup() + const ada = await flaky.as('ada') + await flaky.h.call('PUT', '/v1/agent-credentials/claude', { bearer: ada, body: { token: SETUP_TOKEN } }) + flaky.check.status = 529 + flaky.check.body = '{"type":"error","error":{"type":"overloaded_error"}}' + const kept = await flaky.h.call('POST', '/v1/agent-credentials/claude/verify', { bearer: ada }) + expect(kept.body).toMatchObject({ claude: { state: 'active' }, checked: true, verifiedAt: null }) + // Rate limited: a second call within the minute doesn't ask again. + await flaky.h.call('POST', '/v1/agent-credentials/claude/verify', { bearer: ada }) + expect(flaky.check.calls).toBe(1) + }) + + it('storing a new token forgets the old verification', async () => { + const { h, as, check } = await setup() + const mia = await as('mia') + await h.call('PUT', '/v1/agent-credentials/claude', { bearer: mia, body: { token: SETUP_TOKEN } }) + check.status = 200 + check.body = '{}' + await h.call('POST', '/v1/agent-credentials/claude/verify', { bearer: mia }) + await h.call('PUT', '/v1/agent-credentials/claude', { bearer: mia, body: { token: SETUP_TOKEN } }) + const after = await h.call('POST', '/v1/agent-credentials/claude/verify', { bearer: mia }) + expect(after.body.checked).toBe(true) + expect(check.calls).toBe(2) + }) +}) diff --git a/cloud/apps/sandbox-control/test/api-sessions.test.ts b/cloud/apps/sandbox-control/test/api-sessions.test.ts new file mode 100644 index 00000000000..75e2b457ada --- /dev/null +++ b/cloud/apps/sandbox-control/test/api-sessions.test.ts @@ -0,0 +1,222 @@ +import { gunzipSync } from 'node:zlib' +import { describe, expect, it } from 'vitest' +import { safeFilename } from '../src/api/attachments' +import { tarGzipFile } from '../src/tar-gzip' +import { createHarness } from './harness' + +async function harness() { + const pending: Promise[] = [] + const h = await createHarness({ PUBLIC_API_URL: 'https://api.test' }, { waitUntil: (p) => void pending.push(p) }) + /** Answers the in-VM orca CLI: launches return `term_new`, other terminal commands succeed. */ + h.vercel.commandHandler = (params) => { + const args = params.args ?? [] + if (args.includes('launch')) { + return { exitCode: 0, stdout: JSON.stringify({ ok: true, result: { outcome: { kind: 'terminal', handle: 'term_new' } } }), stderr: '' } + } + if (args.includes('terminal')) { + return { exitCode: 0, stdout: JSON.stringify({ ok: true, result: {} }), stderr: '' } + } + return undefined + } + const orcaArgs = (verb: string) => h.vercel.commands.filter((c) => c.args?.includes(verb)).map((c) => c.args!.slice(c.args!.indexOf('orca') + 1)) + return { ...h, settle: () => Promise.all(pending.splice(0)), orcaArgs } +} + +async function upload(h: Awaited>, wsId: string, init: { body: BodyInit; contentType: string; query?: string; as?: string }) { + const bearer = await h.token(init.as ?? 'alice') + const response = await h.send( + new Request(`https://sandbox.test/v1/workspaces/${wsId}/attachments${init.query ?? ''}`, { + method: 'POST', + headers: { authorization: `Bearer ${bearer}`, 'content-type': init.contentType }, + body: init.body + }) + ) + return { status: response.status, body: (await response.json()) as any } +} + +describe('public API: models', () => { + it('lists every image agent with its catalog models, efforts and defaults', async () => { + const h = await harness() + const res = await h.call('GET', '/v1/models') + expect(res.status).toBe(200) + const agents = res.body.agents as { id: string; default: boolean; defaultModel: string | null; models: { id: string; efforts: string[]; fastMode: boolean }[] }[] + expect(agents.map((a) => a.id)).toEqual(['claude', 'codex', 'opencode', 'gemini', 'cursor', 'copilot']) + const claude = agents.find((a) => a.id === 'claude')! + expect(claude.default).toBe(true) + expect(claude.defaultModel).toBe('sonnet') + expect(claude.models.find((m) => m.id === 'opus')).toMatchObject({ efforts: expect.arrayContaining(['high', 'max']), fastMode: true }) + expect(agents.find((a) => a.id === 'codex')!.models.find((m) => m.id === 'gpt-5.5')!.efforts).toContain('xhigh') + // Agents without a seed catalog still appear: their CLI picks the model. + expect(agents.find((a) => a.id === 'copilot')).toMatchObject({ models: [], defaultModel: null }) + }) +}) + +describe('public API: sessions', () => { + it('starts a new session with model, effort, name and a first prompt, waking a sleeping workspace', async () => { + const h = await harness() + const ws = (await h.call('POST', '/v1/workspaces', { body: {} })).body.workspace + await h.call('POST', `/v1/workspaces/${ws.id}/sleep`) + const res = await h.call('POST', `/v1/workspaces/${ws.id}/sessions`, { + body: { agent: 'codex', model: 'gpt-5.5', effort: 'high', name: 'Review', message: 'review the diff; $(rm -rf /)' } + }) + expect(res.status).toBe(201) + expect(res.body.session).toEqual({ handle: 'term_new', workspaceId: ws.id, agent: 'codex', model: 'gpt-5.5', effort: 'high', name: 'Review' }) + expect((await h.call('GET', `/v1/workspaces/${ws.id}`)).body.workspace.status).toBe('running') + const [launch] = h.orcaArgs('launch') + expect(launch).toEqual(expect.arrayContaining(['--agent', 'codex', '--model=gpt-5.5', '--effort=high', '--prompt=review the diff; $(rm -rf /)'])) + expect(h.orcaArgs('rename')[0]).toEqual(expect.arrayContaining(['--terminal', 'term_new', '--title=Review'])) + const actions = (await h.call('GET', '/v1/audit')).body.entries.map((e: { action: string }) => e.action) + expect(actions[0]).toBe('workspace.session.create') + }) + + it('starts an idle session without a prompt and rejects bad model picks', async () => { + const h = await harness() + const ws = (await h.call('POST', '/v1/workspaces', { body: {} })).body.workspace + expect((await h.call('POST', `/v1/workspaces/${ws.id}/sessions`, { body: {} })).status).toBe(201) + expect(h.orcaArgs('launch')[0]!.some((arg) => arg.startsWith('--prompt'))).toBe(false) + const badEffort = await h.call('POST', `/v1/workspaces/${ws.id}/sessions`, { body: { agent: 'claude', model: 'haiku', effort: 'high' } }) + expect(badEffort).toMatchObject({ status: 400, body: { error: 'invalid_request', reason: 'effort: haiku takes no effort' } }) + expect((await h.call('POST', `/v1/workspaces/${ws.id}/sessions`, { body: { effort: 'high' } })).status).toBe(400) + expect((await h.call('POST', `/v1/workspaces/${ws.id}/sessions`, { body: { model: 'x y' } })).status).toBe(400) + // A model newer than the catalog is passed through to the agent CLI. + expect((await h.call('POST', `/v1/workspaces/${ws.id}/sessions`, { body: { model: 'claude-fable-9', effort: 'max' } })).status).toBe(201) + }) + + it('cancels a turn: drops the session\'s queued messages and interrupts with Escape', async () => { + const h = await harness() + const ws = (await h.call('POST', '/v1/workspaces', { body: {} })).body.workspace + // Two messages still waiting for delivery (e.g. a retry backlog): one for this session, one not. + const insert = h.raw.prepare( + `INSERT INTO workspace_messages (id, sandbox_id, account_id, sent_by, agent, session_handle, body, status, created_at, updated_at) VALUES (?, ?, 'user:alice', 'alice', 'claude', ?, 'x', 'queued', 0, 0)` + ) + insert.run('msg_q1', ws.id, 'term_abc') + insert.run('msg_q2', ws.id, 'term_other') + const res = await h.call('POST', `/v1/workspaces/${ws.id}/sessions/term_abc/cancel`) + expect(res.body).toEqual({ workspaceId: ws.id, session: 'term_abc', interrupted: true, canceledQueuedMessages: 1 }) + expect((await h.call('GET', `/v1/workspaces/${ws.id}/messages/msg_q1`)).body.message).toMatchObject({ status: 'failed', error: 'canceled' }) + expect((await h.call('GET', `/v1/workspaces/${ws.id}/messages/msg_q2`)).body.message.status).toBe('queued') + const send = h.orcaArgs('send').at(-1)! + expect(send).toEqual(expect.arrayContaining(['--terminal', 'term_abc', '--text=\u001b'])) + expect(send).not.toContain('--enter') + // Asleep: nothing to interrupt, and the VM is not woken for it. + await h.call('POST', `/v1/workspaces/${ws.id}/sleep`) + const asleep = await h.call('POST', `/v1/workspaces/${ws.id}/sessions/term_abc/cancel`) + expect(asleep.body).toMatchObject({ interrupted: false, canceledQueuedMessages: 0 }) + expect((await h.call('GET', `/v1/workspaces/${ws.id}`)).body.workspace.status).toBe('sleeping') + expect((await h.call('POST', `/v1/workspaces/${ws.id}/sessions/nope/cancel`)).status).toBe(404) + }) + + it('renames a session while running and 409s while asleep', async () => { + const h = await harness() + const ws = (await h.call('POST', '/v1/workspaces', { body: {} })).body.workspace + const res = await h.call('POST', `/v1/workspaces/${ws.id}/sessions/term_abc/rename`, { body: { name: 'Docs pass' } }) + expect(res.body.session).toEqual({ handle: 'term_abc', workspaceId: ws.id, name: 'Docs pass' }) + await h.call('POST', `/v1/workspaces/${ws.id}/sleep`) + expect((await h.call('POST', `/v1/workspaces/${ws.id}/sessions/term_abc/rename`, { body: { name: 'x' } })).status).toBe(409) + }) + + it('keeps teammates out of a private workspace\'s sessions', async () => { + const h = await harness() + const owner = await h.token('olive', 'acme', 'sandbox', { orgRole: 'owner' }) + const member = await h.token('mel', 'acme', 'sandbox', { orgRole: 'member' }) + const ws = (await h.call('POST', '/v1/workspaces', { bearer: owner, body: {} })).body.workspace + expect((await h.call('POST', `/v1/workspaces/${ws.id}/sessions`, { bearer: member, body: {} })).status).toBe(404) + expect((await h.call('POST', `/v1/workspaces/${ws.id}/sessions/term_abc/cancel`, { bearer: member })).status).toBe(404) + expect((await h.call('POST', `/v1/workspaces/${ws.id}/rename`, { bearer: member, body: { name: 'x' } })).status).toBe(404) + }) +}) + +describe('public API: rename and unarchive', () => { + it('renames a workspace everywhere it is listed', async () => { + const h = await harness() + const ws = (await h.call('POST', '/v1/workspaces', { body: { name: 'old' } })).body.workspace + const res = await h.call('POST', `/v1/workspaces/${ws.id}/rename`, { body: { name: ' New name ' } }) + expect(res.body.workspace.name).toBe('New name') + expect((await h.call('GET', `/v1/workspaces/${ws.id}`)).body.workspace.name).toBe('New name') + expect((await h.call('GET', '/v1/team/workspaces')).body.workspaces[0].title).toBe('New name') + expect((await h.call('POST', `/v1/workspaces/${ws.id}/rename`, { body: { name: '' } })).status).toBe(400) + }) + + it('unarchives back into lists and running, idempotently', async () => { + const h = await harness() + const ws = (await h.call('POST', '/v1/workspaces', { body: {} })).body.workspace + await h.call('POST', `/v1/workspaces/${ws.id}/archive`) + expect((await h.call('GET', '/v1/workspaces')).body.workspaces).toHaveLength(0) + const res = await h.call('POST', `/v1/workspaces/${ws.id}/unarchive`) + expect(res.body.workspace).toMatchObject({ status: 'running', archived: false }) + expect((await h.call('GET', '/v1/workspaces')).body.workspaces).toHaveLength(1) + const again = await h.call('POST', `/v1/workspaces/${ws.id}/unarchive`) + expect(again).toMatchObject({ status: 200, body: { workspace: { status: 'running', archived: false } } }) + const actions = (await h.call('GET', '/v1/audit')).body.entries.map((e: { action: string }) => e.action) + expect(actions.filter((a: string) => a === 'workspace.unarchive')).toHaveLength(1) + }) +}) + +describe('public API: attachments', () => { + it('writes raw and base64 uploads to the workspace disk and points the agent at them', async () => { + const h = await harness() + const ws = (await h.call('POST', '/v1/workspaces', { body: {} })).body.workspace + const raw = await upload(h, ws.id, { body: new Uint8Array([0x89, 0x50, 0x4e, 0x47]), contentType: 'image/png', query: '?filename=../../etc/Screen%20Shot%201.png' }) + expect(raw.status).toBe(201) + const att = raw.body.attachment + expect(att).toMatchObject({ workspaceId: ws.id, filename: 'Screen Shot 1.png', contentType: 'image/png', byteSize: 4 }) + expect(att.path).toBe(`/vercel/sandbox/attachments/${att.id}/Screen Shot 1.png`) + const box = [...h.vercel.boxes.values()][0]! + expect(Buffer.from(box.files.get(att.path)!, 'latin1')).toEqual(Buffer.from([0x89, 0x50, 0x4e, 0x47])) + + const json = await upload(h, ws.id, { body: JSON.stringify({ filename: 'log.txt', contentType: 'text/plain', data: Buffer.from('boom').toString('base64') }), contentType: 'application/json' }) + expect(json.body.attachment).toMatchObject({ filename: 'log.txt', byteSize: 4 }) + + const sent = await h.call('POST', `/v1/workspaces/${ws.id}/messages`, { body: { text: 'see files', attachments: [att.id, json.body.attachment.id] } }) + expect(sent.status).toBe(202) + await h.settle() + const prompt = h.orcaArgs('launch')[0]!.at(-1)! + expect(prompt).toContain('see files\n\nAttached files (read them from disk):') + expect(prompt).toContain(`- ${att.path} (image/png, 4 bytes)`) + expect(prompt).toContain(`- ${json.body.attachment.path} (text/plain, 4 bytes)`) + }) + + it('rejects unknown, foreign and oversized attachments', async () => { + const h = await harness() + const a = (await h.call('POST', '/v1/workspaces', { body: {} })).body.workspace + const b = (await h.call('POST', '/v1/workspaces', { body: {} })).body.workspace + const att = (await upload(h, b.id, { body: 'x', contentType: 'text/plain', query: '?filename=x.txt' })).body.attachment + const foreign = await h.call('POST', `/v1/workspaces/${a.id}/messages`, { body: { text: 'hi', attachments: [att.id] } }) + expect(foreign).toMatchObject({ status: 400, body: { error: 'invalid_request' } }) + expect((await h.call('POST', `/v1/workspaces/${a.id}/messages`, { body: { text: 'hi', attachments: ['att_nope'] } })).status).toBe(400) + expect((await upload(h, a.id, { body: 'x', contentType: 'text/plain' })).status).toBe(400) + const big = await upload(h, a.id, { body: JSON.stringify({ filename: 'big.bin', data: Buffer.alloc(5 * 1024 * 1024 + 1).toString('base64') }), contentType: 'application/json' }) + expect(big.status).toBe(413) + // Another account cannot upload into it. + expect((await upload(h, a.id, { body: 'x', contentType: 'text/plain', query: '?filename=x', as: 'mallory' })).status).toBe(404) + // Attachments need a message on session create. + expect((await h.call('POST', `/v1/workspaces/${b.id}/sessions`, { body: { attachments: [att.id] } })).status).toBe(400) + }) + + it('keeps file names to one safe path segment', () => { + expect(safeFilename('../../.ssh/id_rsa')).toBe('id_rsa') + expect(safeFilename('.env')).toBe('env') + expect(safeFilename('résumé $(x).pdf')).toBe('resume __x_.pdf') + expect(safeFilename('')).toBe('file') + expect(safeFilename(`${'a'.repeat(300)}.png`)).toMatch(/^a{80}\.png$/) + }) + + it('packs a valid ustar archive the files API can extract', async () => { + const bytes = new TextEncoder().encode('hello') + const tgz = new Uint8Array(await tarGzipFile({ dirs: ['vercel', 'vercel/sandbox'], path: 'vercel/sandbox/a.txt', bytes, mtime: 1_700_000_000_000 })) + const tar = gunzipSync(tgz) + expect(tar.length % 512).toBe(0) + const field = (block: number, offset: number, width: number) => tar.subarray(block * 512 + offset, block * 512 + offset + width).toString('latin1').replace(/\0.*$/s, '') + expect([field(0, 0, 100), field(0, 156, 1), field(1, 0, 100), field(2, 0, 100), field(2, 156, 1)]).toEqual(['vercel/', '5', 'vercel/sandbox/', 'vercel/sandbox/a.txt', '0']) + expect(parseInt(field(2, 124, 12), 8)).toBe(5) + expect(field(2, 257, 6)).toBe('ustar') + for (const block of [0, 1, 2]) { + const header = Buffer.from(tar.subarray(block * 512, block * 512 + 512)) + const stored = parseInt(field(block, 148, 8), 8) + header.fill(0x20, 148, 156) + expect(header.reduce((sum, b) => sum + b, 0)).toBe(stored) + } + expect(tar.subarray(3 * 512, 3 * 512 + 5).toString()).toBe('hello') + await expect(tarGzipFile({ dirs: [], path: '../x', bytes, mtime: 0 })).rejects.toThrow('tar_bad_path') + }) +}) diff --git a/cloud/apps/sandbox-control/test/auto-environments.test.ts b/cloud/apps/sandbox-control/test/auto-environments.test.ts new file mode 100644 index 00000000000..cb12b135dc8 --- /dev/null +++ b/cloud/apps/sandbox-control/test/auto-environments.test.ts @@ -0,0 +1,141 @@ +// Automatic environments: the first create of a repo builds it in the background; later creates boot +// with the repo checked out and only fetch what changed. +import { describe, expect, it } from 'vitest' +import { HostedSandboxReadyResponseSchema } from '../../../../src/shared/hosted-sandbox/hosted-sandbox-wire' +import { AUTO_ENVIRONMENT_UNUSED_MS, expireAutoEnvironments } from '../src/auto-environments' +import { START_COMMAND } from '../src/sandbox-vm-commands' +import { GOLDEN, createHarness } from './harness' + +const REPO = 'https://github.com/acme/web.git' +const RESULT = JSON.stringify({ + durationSec: 3, + repos: [{ url: REPO, dir: 'acme/web', branch: 'main', commit: 'a'.repeat(40), lockfiles: {} }], + diskUsedBytes: 3_000_000_000, + diskTotalBytes: 34_000_000_000 +}) +const FEATURES = { 'x-orca-sandbox-features': 'clone-progress,repo-update' } + +async function setup() { + const pending: Promise[] = [] + const h = await createHarness({ AUTO_ENVIRONMENTS: 'on' }, { waitUntil: (work: Promise) => void pending.push(work) }) + h.vercel.buildResult = RESULT + const settle = async () => { + while (pending.length > 0) { + await Promise.all(pending.splice(0)) + } + } + const environments = () => + h.raw.prepare('SELECT id, account_id, kind, name, active_build_id, deleted_at, last_used_at FROM environments').all() as { + id: string + account_id: string + kind: string + name: string + active_build_id: string | null + deleted_at: number | null + last_used_at: number | null + }[] + /** Lets the auto build's VM command succeed and finalizes it. */ + async function finishBuild(as = 'alice') { + const env = environments().find((row) => row.deleted_at === null && !row.active_build_id)! + const build = h.raw.prepare('SELECT id FROM environment_builds WHERE environment_id = ? ORDER BY number DESC').get(env.id) as { id: string } + const command = [...h.vercel.buildCommands.values()].at(-1)! + command.logs = `${JSON.stringify({ data: '::orca-step:: clone\n', stream: 'stdout' })}\n` + command.exitCode = 0 + h.advance(1000) + const done = await h.call('GET', `/v1/environments/${env.id}/builds/${build.id}`, { as }) + expect(done.body.build.status).toBe('succeeded') + return { env, buildId: build.id } + } + return { h, settle, environments, finishBuild } +} + +describe('automatic environments', () => { + it('the first create of a repo builds it (blobless); the next boots with it checked out and fetches only changes', async () => { + const { h, settle, environments, finishBuild } = await setup() + const first = await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'w1', machineSize: 'standard', repo: { url: REPO } }, headers: FEATURES }) + expect(first.body.clone).toEqual({ state: 'running' }) + await settle() + expect(environments()).toMatchObject([{ kind: 'auto', name: 'acme/web', active_build_id: null }]) + const command = [...h.vercel.buildCommands.values()].at(-1)! + expect(command.env.ORCA_CLONE_FILTER).toBe('blob:none') + const { buildId } = await finishBuild() + + h.vercel.commands.length = 0 + const second = await h.call('POST', '/v1/sandboxes', { + body: { workspaceId: 'w2', machineSize: 'standard', repo: { url: REPO, ref: 'feature' } }, + headers: FEATURES + }) + expect(second.status).toBe(200) + expect(second.body.sandbox.environmentBuildId).toBe(buildId) + expect(second.body.clone).toEqual({ state: 'running', mode: 'update' }) + expect(HostedSandboxReadyResponseSchema.safeParse({ ...second.body, clone: { state: 'running' } }).success).toBe(true) + const start = h.vercel.commands.find((c) => c.command === START_COMMAND)! + expect(start.env).toMatchObject({ ORCA_ENV_REPO_DIR: 'acme/web', ORCA_CLONE_BACKGROUND: '1' }) + const box = [...h.vercel.boxes.values()].find((b) => b.params.tags.orcaSandbox === second.body.sandbox.id)! + expect(box.params.snapshotId).not.toBe(GOLDEN) + await settle() + expect(environments()[0]!.last_used_at).toBe(h.now()) + // A desktop without `repo-update` sees the plain clone shape it knows. + const older = await h.call('POST', '/v1/sandboxes', { + body: { workspaceId: 'w3', machineSize: 'standard', repo: { url: REPO } }, + headers: { 'x-orca-sandbox-features': 'clone-progress' } + }) + expect(older.body.clone).toEqual({ state: 'running' }) + }) + + it('is per account, never shadows an admin environment, and makes one environment per repo', async () => { + const { h, settle, environments } = await setup() + await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'a1', machineSize: 'standard', repo: { url: REPO } } }) + await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'a2', machineSize: 'standard', repo: { url: 'acme/web' } } }) + await settle() + const bob = await h.call('POST', '/v1/sandboxes', { as: 'bob', body: { workspaceId: 'b1', machineSize: 'standard', repo: { url: REPO } } }) + await settle() + expect(bob.body.sandbox.environmentBuildId).toBeUndefined() + const rows = environments() + expect(rows).toHaveLength(2) + expect(new Set(rows.map((row) => row.account_id)).size).toBe(2) + + // An org whose admin lists the repo: no automatic one next to it. + const admin = await h.token('carol', 'acme', 'sandbox', { orgRole: 'admin' }) + expect( + (await h.call('POST', '/v1/environments', { bearer: admin, body: { name: 'Web', repos: [{ url: 'acme/web' }], installScript: '' } })).status + ).toBe(200) + await h.call('POST', '/v1/sandboxes', { bearer: admin, body: { workspaceId: 'c1', machineSize: 'standard', repo: { url: REPO } } }) + await settle() + expect(environments().filter((row) => row.kind === 'auto')).toHaveLength(2) + }) + + it('boot-plan says clone before the environment exists and update after (PC-4)', async () => { + const { h, settle, finishBuild } = await setup() + const plan = async () => (await h.call('GET', `/v1/sandboxes/boot-plan?repo=${encodeURIComponent(REPO)}`)).body + expect(await plan()).toEqual({ repo: 'clone' }) + await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'w1', machineSize: 'standard', repo: { url: REPO } } }) + await settle() + expect(await plan()).toEqual({ repo: 'clone' }) + await finishBuild() + expect(await plan()).toEqual({ repo: 'update' }) + // Another account's environment is never theirs to boot. + expect((await h.call('GET', `/v1/sandboxes/boot-plan?repo=${encodeURIComponent(REPO)}`, { as: 'bob' })).body).toEqual({ + repo: 'clone' + }) + }) + + it('goes after 14 days unused, with its snapshot', async () => { + const { h, settle, environments, finishBuild } = await setup() + await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'w1', machineSize: 'standard', repo: { url: REPO } } }) + await settle() + const { buildId } = await finishBuild() + const snapshotId = (h.raw.prepare('SELECT snapshot_id FROM environment_builds WHERE id = ?').get(buildId) as { snapshot_id: string }).snapshot_id + h.advance(AUTO_ENVIRONMENT_UNUSED_MS + 60_000) + const deps = { + db: h.env.SANDBOX_DB, + provider: h.vercel, + entitlements: { checkStart: async () => h.billing.decision, reportUsage: async () => h.billing.usageAnswer, listSuspensions: async () => [] }, + now: h.now, + config: { environment: 'test', goldenSnapshotId: GOLDEN, region: 'iad1' } + } + expect(await expireAutoEnvironments(deps as never)).toBe(1) + expect(environments()[0]!.deleted_at).not.toBeNull() + expect(h.vercel.snapshots.get(snapshotId)?.status).not.toBe('created') + }) +}) diff --git a/cloud/apps/sandbox-control/test/create-speed.test.ts b/cloud/apps/sandbox-control/test/create-speed.test.ts index cb19f543a76..fb5d963451c 100644 --- a/cloud/apps/sandbox-control/test/create-speed.test.ts +++ b/cloud/apps/sandbox-control/test/create-speed.test.ts @@ -137,6 +137,28 @@ describe('repo-backed create', () => { expect(h.billing.requests[0]).toMatchObject({ runningSandboxes: 3, runningSandboxesForUser: 3 }) }) + it('an Idempotency-Key makes one sandbox per intent, for that account and member only (PC-8)', async () => { + const h = await createHarness() + const key = { 'idempotency-key': 'create-press-0001' } + const first = await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'w-a', machineSize: 'standard' }, headers: key }) + expect(first.status).toBe(200) + // A re-fired start of the same press (same key, same body): the same sandbox, nothing new. + const again = await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'w-a', machineSize: 'standard' }, headers: key }) + expect(again.status).toBe(200) + expect(again.body.sandbox.id).toBe(first.body.sandbox.id) + expect(h.vercel.boxes.size).toBe(1) + // Same key, different request: refused, not silently merged. + const other = await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'w-b', machineSize: 'standard' }, headers: key }) + expect(other.status).toBe(422) + // Keys are per member: someone else's press with the same key is their own create. + const bob = await h.call('POST', '/v1/sandboxes', { as: 'bob', body: { workspaceId: 'w-a', machineSize: 'standard' }, headers: key }) + expect(bob.status).toBe(200) + expect(bob.body.sandbox.id).not.toBe(first.body.sandbox.id) + // A bad key is a 400, before anything starts. + const bad = await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'w-c', machineSize: 'standard' }, headers: { 'idempotency-key': 'x' } }) + expect(bad.status).toBe(400) + }) + it('a create whose Worker was cut off is failed after 5 minutes, not 15', async () => { const h = await createHarness() const { body } = await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'ws-1', machineSize: 'standard' } }) @@ -153,3 +175,18 @@ describe('repo-backed create', () => { expect(h.vercel.boxes.size).toBe(0) }) }) + +describe('VM hostname (JA-27)', () => { + it('is the workspace name (else the repo), as a hostname label, set at every start', async () => { + const { workspaceHostname } = await import('../src/sandbox-vm-commands') + expect(workspaceHostname('Fix Login Bug!')).toBe('fix-login-bug') + expect(workspaceHostname('--ja_hello--')).toBe('ja-hello') + expect(workspaceHostname('🙂')).toBeUndefined() + expect(workspaceHostname('a'.repeat(80))).toHaveLength(63) + const h = await createHarness() + await h.call('POST', '/v1/sandboxes', { body: { workspaceId: 'w1', machineSize: 'standard', title: 'Ja Hello', repo } }) + const start = h.vercel.commands.find((c) => c.command === START_COMMAND)! + expect(start.env.ORCA_HOSTNAME).toBe('ja-hello') + expect(start.args?.[1]).toContain('sudo -n hostname "$ORCA_HOSTNAME"') + }) +}) diff --git a/cloud/apps/sandbox-control/test/fake-vercel.ts b/cloud/apps/sandbox-control/test/fake-vercel.ts index 54bf12b0bfe..d8e59b79073 100644 --- a/cloud/apps/sandbox-control/test/fake-vercel.ts +++ b/cloud/apps/sandbox-control/test/fake-vercel.ts @@ -369,6 +369,13 @@ export function createFakeVercel(now: () => number): FakeVercel { async readFile(sessionId, path) { return bySession(sessionId).files.get(path) ?? null }, + async writeFile(sessionId, path, bytes) { + const box = bySession(sessionId) + if (box.status !== 'running') { + throw new ProviderError(410, 'sandbox_stopped') + } + box.files.set(path, Buffer.from(bytes).toString('latin1')) + }, async deleteSandbox(name) { const box = boxes.get(name) if (box?.status === 'running') { diff --git a/cloud/apps/sandbox-control/test/harness.ts b/cloud/apps/sandbox-control/test/harness.ts index f741c315869..6687138c0e5 100644 --- a/cloud/apps/sandbox-control/test/harness.ts +++ b/cloud/apps/sandbox-control/test/harness.ts @@ -50,6 +50,8 @@ export async function createHarness(overrides: Partial = {}, extraDeps: Par GOLDEN_SNAPSHOT_ID: GOLDEN, VERCEL_TEAM_ID: 'team_orca', VERCEL_PROJECT_ID: 'prj_orca', + // Off unless a test turns it on (auto-environments.test.ts): it starts builds behind creates. + AUTO_ENVIRONMENTS: 'off', ...overrides } // No live github.com from tests: repos count as public unless a test says otherwise. diff --git a/cloud/apps/sandbox-control/test/mcp.test.ts b/cloud/apps/sandbox-control/test/mcp.test.ts index 7abafbeeb85..f9e35ac23a8 100644 --- a/cloud/apps/sandbox-control/test/mcp.test.ts +++ b/cloud/apps/sandbox-control/test/mcp.test.ts @@ -130,9 +130,13 @@ describe('MCP protocol', () => { const list = await h.rpc(key, 'tools/list', {}, { 'mcp-protocol-version': '2025-11-25' }) const tools = list.body.result.tools as { name: string; inputSchema: any; annotations: any; description: string }[] expect(tools.map((t) => t.name)).toEqual([ - 'whoami', 'list_projects', 'list_workspaces', 'get_workspace', 'create_workspace', 'sleep_workspace', 'wake_workspace', - 'archive_workspace', 'destroy_workspace', 'send_message', 'get_message', 'list_sessions', 'read_session', 'list_routines', 'run_routine' + 'whoami', 'list_models', 'list_projects', 'list_workspaces', 'get_workspace', 'create_workspace', 'rename_workspace', + 'sleep_workspace', 'wake_workspace', 'archive_workspace', 'unarchive_workspace', 'destroy_workspace', 'create_session', + 'cancel_session', 'rename_session', 'upload_attachment', 'send_message', 'get_message', 'list_sessions', 'read_session', + 'list_routines', 'run_routine' ]) + // Conductor's 20 tools minus run_sql (transcripts are end-to-end encrypted on the VM), plus Orca's own. + expect(tools).toHaveLength(22) for (const t of tools) { expect(t.inputSchema.type).toBe('object') expect(t.description.length).toBeGreaterThan(40) @@ -144,6 +148,38 @@ describe('MCP protocol', () => { expect(byName.send_message!.inputSchema.required).toEqual(['workspaceId', 'text']) }) + it('starts, renames and cancels sessions, uploads files and lists models through the new tools', async () => { + const h = await harness() + const key = await h.apiKey(['workspaces:read', 'workspaces:write', 'messages:write']) + h.vercel.commandHandler = (params) => { + const args = params.args ?? [] + if (args.includes('launch')) { + return { exitCode: 0, stdout: JSON.stringify({ ok: true, result: { outcome: { kind: 'terminal', handle: 'term_mcp1' } } }), stderr: '' } + } + if (args.includes('terminal')) { + return { exitCode: 0, stdout: JSON.stringify({ ok: true, result: {} }), stderr: '' } + } + return undefined + } + const models = (await h.tool(key, 'list_models')).structuredContent.agents + expect(models.map((a: { id: string }) => a.id)).toContain('codex') + const ws = (await h.tool(key, 'create_workspace', { name: 'm' })).structuredContent.workspace + expect((await h.tool(key, 'rename_workspace', { workspaceId: ws.id, name: 'renamed' })).structuredContent.workspace.name).toBe('renamed') + const file = await h.tool(key, 'upload_attachment', { workspaceId: ws.id, filename: 'shot.png', contentType: 'image/png', data: Buffer.from('PNGDATA').toString('base64') }) + expect(file.isError).toBeUndefined() + const attachment = file.structuredContent.attachment + expect(attachment).toMatchObject({ filename: 'shot.png', byteSize: 7, contentType: 'image/png' }) + const session = await h.tool(key, 'create_session', { workspaceId: ws.id, agent: 'codex', model: 'gpt-5.5', effort: 'high', name: 'Second', message: 'look', attachments: [attachment.id] }) + expect(session.structuredContent.session).toMatchObject({ handle: 'term_mcp1', agent: 'codex', model: 'gpt-5.5', name: 'Second' }) + const launch = h.vercel.commands.find((c) => c.args?.includes('launch'))! + expect(launch.args).toContain('--model=gpt-5.5') + expect(launch.args!.at(-1)).toContain(attachment.path) + expect((await h.tool(key, 'rename_session', { workspaceId: ws.id, session: 'term_mcp1', name: 'Third' })).structuredContent.session.name).toBe('Third') + expect((await h.tool(key, 'cancel_session', { workspaceId: ws.id, session: 'term_mcp1' })).structuredContent).toMatchObject({ interrupted: true, canceledQueuedMessages: 0 }) + await h.tool(key, 'archive_workspace', { workspaceId: ws.id }) + expect((await h.tool(key, 'unarchive_workspace', { workspaceId: ws.id })).structuredContent.workspace).toMatchObject({ status: 'running', archived: false }) + }) + it('rejects bad transport input: method, origin, version header, JSON, unknown method/tool', async () => { const h = await harness() const key = await h.apiKey(['workspaces:read']) diff --git a/cloud/apps/sandbox-control/test/team-presence.test.ts b/cloud/apps/sandbox-control/test/team-presence.test.ts new file mode 100644 index 00000000000..8a47fe8e2f7 --- /dev/null +++ b/cloud/apps/sandbox-control/test/team-presence.test.ts @@ -0,0 +1,197 @@ +import { describe, expect, it } from 'vitest' +import { usageLevel } from '../src/team-presence' +import { createHarness } from './harness' + +const MIN = 60_000 +const HOUR = 60 * MIN +const DAY = 24 * HOUR + +async function team() { + const h = await createHarness({ OPERATOR_TOKEN: 'o'.repeat(40) }) + type Who = { sub: string; orgRole: 'owner' | 'admin' | 'member'; org?: string; name?: string } + const req = async (who: Who, method: string, path: string, body?: unknown) => + h.call(method, path, { + bearer: await h.token(who.sub, who.org === undefined ? 'acme' : who.org || undefined, 'sandbox', { + org_role: who.orgRole, + ...(who.name ? { name: who.name } : {}) + }), + body + }) + const alice: Who = { sub: 'alice', orgRole: 'member', name: 'Alice Doe' } + const bob: Who = { sub: 'bob', orgRole: 'member', name: 'Bob Roe' } + return { h, req, alice, bob } +} + +describe('teammate profiles', () => { + it('shows a teammate only their team workspaces and a 0–4 heatmap, never amounts', async () => { + const t = await team() + const shared = await t.req(t.alice, 'POST', '/v1/sandboxes', { workspaceId: 'ws-1', machineSize: 'standard', title: 'Shared' }) + const secret = await t.req(t.alice, 'POST', '/v1/sandboxes', { workspaceId: 'ws-2', machineSize: 'standard', title: 'Secret' }) + expect(shared.status).toBe(200) + const sharedId = shared.body.sandbox.id as string + const secretId = secret.body.sandbox.id as string + await t.req(t.alice, 'PATCH', `/v1/team/workspaces/${sharedId}`, { visibility: 'team' }) + const now = t.h.now() + // Two hours of sandbox time yesterday on the private one, half an hour today on the shared one. + const outbox = t.h.raw.prepare( + `INSERT INTO usage_outbox (usage_id, sandbox_id, account_id, machine_size, started_at, ended_at) VALUES (?, ?, ?, 'standard', ?, ?)` + ) + const accountId = (t.h.raw.prepare('SELECT account_id FROM sandboxes WHERE id = ?').get(sharedId) as { account_id: string }).account_id + outbox.run('u1', secretId, accountId, now - DAY - 2 * HOUR, now - DAY) + outbox.run('u2', sharedId, accountId, now - 30 * MIN, now) + + // Not shared until Alice turns on "Pokes and activity"; workspaces she shared still show. + const hidden = (await t.req(t.bob, 'GET', '/v1/team/members/alice/profile?utcOffsetMin=0')).body.profile + expect(hidden).toMatchObject({ usage: null, pokes: { enabled: false, teammateEnabled: false } }) + expect(hidden.recentWorkspaces).toHaveLength(1) + await t.req(t.alice, 'PUT', '/v1/team/pokes/settings', { enabled: true }) + + const seen = await t.req(t.bob, 'GET', '/v1/team/members/alice/profile?utcOffsetMin=0') + expect(seen.status).toBe(200) + const profile = seen.body.profile + expect(profile).toMatchObject({ userId: 'alice', self: false, name: 'Alice Doe', pokes: { enabled: false, teammateEnabled: true } }) + expect(profile.recentWorkspaces.map((w: { id: string }) => w.id)).toEqual([sharedId]) + expect(profile.usage.own).toBeNull() + expect(profile.usage.levels).toHaveLength(182) + expect(profile.usage.activeDays).toBe(2) + // Relative to her own busiest day: yesterday is the max (4), today a quarter of it (1). + expect(profile.usage.levels.slice(-2)).toEqual([4, 1]) + expect(JSON.stringify(profile.usage)).not.toMatch(/usdMicros|computeMs/) + + const own = await t.req(t.alice, 'GET', '/v1/team/members/alice/profile?utcOffsetMin=0') + expect(own.body.profile.self).toBe(true) + expect(own.body.profile.recentWorkspaces).toHaveLength(2) + expect(own.body.profile.usage.own.computeMs.slice(-2)).toEqual([2 * HOUR, 30 * MIN]) + expect(own.body.profile.usage.own.usdMicros.at(-1)).toBeGreaterThan(0) + }) + + it('splits a session across local midnight and dates reported model spend', async () => { + const t = await team() + const created = await t.req(t.alice, 'POST', '/v1/sandboxes', { workspaceId: 'ws-1', machineSize: 'standard' }) + const id = created.body.sandbox.id as string + const now = t.h.now() + const accountId = (t.h.raw.prepare('SELECT account_id FROM sandboxes WHERE id = ?').get(id) as { account_id: string }).account_id + const midnight = Math.floor(now / DAY) * DAY + t.h.raw + .prepare(`INSERT INTO usage_outbox (usage_id, sandbox_id, account_id, machine_size, started_at, ended_at) VALUES ('u1', ?, ?, 'standard', ?, ?)`) + .run(id, accountId, midnight - HOUR, midnight + HOUR) + expect((await t.req(t.alice, 'PATCH', `/v1/team/workspaces/${id}`, { tokenUsdMicros: 500_000 })).status).toBe(200) + expect((await t.req(t.alice, 'PATCH', `/v1/team/workspaces/${id}`, { tokenUsdMicros: 400_000 })).status).toBe(200) + expect((await t.req(t.alice, 'PATCH', `/v1/team/workspaces/${id}`, { tokenUsdMicros: 700_000 })).status).toBe(200) + const own = (await t.req(t.alice, 'GET', '/v1/team/members/alice/profile?utcOffsetMin=0')).body.profile.usage.own + const today = own.computeMs.length - 1 + const tokenAndCompute = own.usdMicros[today] + expect(own.computeMs[today - 1]).toBe(HOUR) + // Only increases count: 500k, then nothing for the drop to 400k, then 300k more. + expect(tokenAndCompute - own.usdMicros[today - 1]).toBe(500_000 + 300_000) + }) + + it('shares every teammate\'s activity when the account config says team', async () => { + const h = await createHarness({ TEAMMATE_ACTIVITY_SHARING: 'team' }) + const bob = await h.token('bob', 'acme', 'sandbox', { org_role: 'member' }) + const seen = await h.call('GET', '/v1/team/members/alice/profile', { bearer: bob }) + expect(seen.body.profile.usage.levels).toHaveLength(182) + expect(seen.body.profile.usage.own).toBeNull() + }) + + it('keeps personal accounts to themselves and rejects bad ids', async () => { + const t = await team() + const solo = { sub: 'solo', orgRole: 'owner' as const, org: '' } + expect((await t.req(solo, 'GET', '/v1/team/members/alice/profile')).status).toBe(404) + expect((await t.req(solo, 'GET', '/v1/team/members/solo/profile')).status).toBe(200) + expect((await t.req(t.bob, 'GET', '/v1/team/members/a%20b/profile')).status).toBe(400) + const stranger = { sub: 'eve', orgRole: 'owner' as const, org: 'other' } + expect((await t.req(stranger, 'GET', '/v1/team/members/alice/profile')).body.profile.recentWorkspaces).toEqual([]) + }) + + it('levels are relative to the busiest day', () => { + expect([0, 1, 25, 26, 50, 100].map((v) => usageLevel(v, 100))).toEqual([0, 1, 1, 2, 2, 4]) + expect(usageLevel(5, 0)).toBe(0) + }) +}) + +describe('pokes', () => { + it('needs both people opted in, then delivers, rate-limits and acks', async () => { + const t = await team() + expect(await t.req(t.alice, 'POST', '/v1/team/members/bob/poke')).toMatchObject({ status: 409, body: { reason: 'pokes_off' } }) + expect((await t.req(t.alice, 'PUT', '/v1/team/pokes/settings', { enabled: true })).body).toEqual({ enabled: true }) + expect(await t.req(t.alice, 'POST', '/v1/team/members/bob/poke')).toMatchObject({ status: 409, body: { reason: 'teammate_pokes_off' } }) + const before = (await t.req(t.alice, 'GET', '/v1/team/members/bob/profile')).body.profile.pokes + expect(before).toEqual({ enabled: true, teammateEnabled: false }) + await t.req(t.bob, 'PUT', '/v1/team/pokes/settings', { enabled: true }) + expect((await t.req(t.alice, 'GET', '/v1/team/members/bob/profile')).body.profile.pokes.teammateEnabled).toBe(true) + + const sent = await t.req(t.alice, 'POST', '/v1/team/members/bob/poke') + expect(sent.status).toBe(200) + const again = await t.req(t.alice, 'POST', '/v1/team/members/bob/poke') + expect(again).toMatchObject({ status: 429, body: { reason: 'poke_cooldown' } }) + expect(again.body.retryAfterMs).toBeGreaterThan(0) + expect(await t.req(t.alice, 'POST', '/v1/team/members/alice/poke')).toMatchObject({ status: 400, body: { reason: 'self' } }) + + const inbox = await t.req(t.bob, 'GET', '/v1/team/pokes') + expect(inbox.body.enabled).toBe(true) + expect(inbox.body.pokes).toEqual([{ id: sent.body.poke.id, fromUserId: 'alice', fromName: 'Alice Doe', at: t.h.now() }]) + // Alice sees nothing addressed to her; another org sees nothing at all. + expect((await t.req(t.alice, 'GET', '/v1/team/pokes')).body.pokes).toEqual([]) + expect((await t.req({ sub: 'bob', orgRole: 'member', org: 'other' }, 'GET', '/v1/team/pokes')).body.pokes).toEqual([]) + + expect((await t.req(t.bob, 'POST', '/v1/team/pokes/seen', { ids: [sent.body.poke.id] })).status).toBe(200) + expect((await t.req(t.bob, 'GET', '/v1/team/pokes')).body.pokes).toEqual([]) + + // Poke back works, and after the cooldown Alice may poke again. + expect((await t.req(t.bob, 'POST', '/v1/team/members/alice/poke')).status).toBe(200) + t.h.advance(61_000) + expect((await t.req(t.alice, 'POST', '/v1/team/members/bob/poke')).status).toBe(200) + }) + + it('caps pokes per sender per hour and drops stale or opted-out ones', async () => { + const t = await team() + await t.req(t.alice, 'PUT', '/v1/team/pokes/settings', { enabled: true }) + const teammates = Array.from({ length: 21 }, (_, i) => ({ sub: `m${i}`, orgRole: 'member' as const })) + for (const m of teammates) { + await t.req(m, 'PUT', '/v1/team/pokes/settings', { enabled: true }) + } + for (const m of teammates.slice(0, 20)) { + expect((await t.req(t.alice, 'POST', `/v1/team/members/${m.sub}/poke`)).status).toBe(200) + } + expect(await t.req(t.alice, 'POST', '/v1/team/members/m20/poke')).toMatchObject({ status: 429, body: { reason: 'poke_rate' } }) + // Turning Pokes off clears what was waiting; a day-old poke is never shown. + expect((await t.req(teammates[0]!, 'GET', '/v1/team/pokes')).body.pokes).toHaveLength(1) + await t.req(teammates[0]!, 'PUT', '/v1/team/pokes/settings', { enabled: false }) + await t.req(teammates[0]!, 'PUT', '/v1/team/pokes/settings', { enabled: true }) + expect((await t.req(teammates[0]!, 'GET', '/v1/team/pokes')).body.pokes).toEqual([]) + t.h.advance(DAY + MIN) + expect((await t.req(teammates[1]!, 'GET', '/v1/team/pokes')).body.pokes).toEqual([]) + }) + + it('forgets a removed member so nobody can poke them', async () => { + const t = await team() + await t.req(t.alice, 'PUT', '/v1/team/pokes/settings', { enabled: true }) + await t.req(t.bob, 'PUT', '/v1/team/pokes/settings', { enabled: true }) + const removed = await t.h.call('POST', '/v1/internal/org-members/removed', { bearer: 'o'.repeat(40), body: { accountId: 'org:acme', userId: 'bob' } }) + expect(removed.status).toBe(200) + expect(await t.req(t.alice, 'POST', '/v1/team/members/bob/poke')).toMatchObject({ status: 409, body: { reason: 'teammate_pokes_off' } }) + }) + + it('refuses Pokes on a personal account', async () => { + const t = await team() + const solo = { sub: 'solo', orgRole: 'owner' as const, org: '' } + expect(await t.req(solo, 'PUT', '/v1/team/pokes/settings', { enabled: true })).toMatchObject({ status: 400, body: { reason: 'personal_account' } }) + expect((await t.req(solo, 'GET', '/v1/team/pokes')).body).toEqual({ enabled: false, pokes: [] }) + }) +}) + +describe('member-removed token', () => { + it('authorizes only POST /v1/internal/org-members/removed, never other operator routes', async () => { + const MR = 'm'.repeat(40) + const body = { accountId: 'org:acme', userId: 'bob' } + const h = await createHarness({ OPERATOR_TOKEN: 'o'.repeat(40), MEMBER_REMOVED_TOKEN: MR }) + expect((await h.call('POST', '/v1/internal/org-members/removed', { bearer: MR, body })).status).toBe(200) + expect((await h.call('GET', '/v1/internal/status', { bearer: MR })).status).toBe(404) + expect((await h.call('POST', '/v1/internal/members/removed', { bearer: MR, body })).status).toBe(404) + // The operator token still works on the route; a short token is never accepted. + expect((await h.call('POST', '/v1/internal/org-members/removed', { bearer: 'o'.repeat(40), body })).status).toBe(200) + const weak = await createHarness({ OPERATOR_TOKEN: 'o'.repeat(40), MEMBER_REMOVED_TOKEN: 'short' }) + expect((await weak.call('POST', '/v1/internal/org-members/removed', { bearer: 'short', body })).status).toBe(404) + }) +}) diff --git a/cloud/apps/sandbox-control/test/workspace-numbers-prefs.test.ts b/cloud/apps/sandbox-control/test/workspace-numbers-prefs.test.ts new file mode 100644 index 00000000000..270c1d2be83 --- /dev/null +++ b/cloud/apps/sandbox-control/test/workspace-numbers-prefs.test.ts @@ -0,0 +1,175 @@ +import { readFileSync, readdirSync } from 'node:fs' +import { DatabaseSync } from 'node:sqlite' +import { fileURLToPath } from 'node:url' +import { describe, expect, it } from 'vitest' +import { isValidSlug, slugify } from '../src/org-slugs' +import { createHarness } from './harness' + +type Role = 'owner' | 'admin' | 'member' +type Who = { sub: string; org?: string; role: Role } + +async function setup() { + const h = await createHarness() + const req = async (who: Who, method: string, path: string, body?: unknown) => + h.call(method, path, { bearer: await h.token(who.sub, who.org, 'sandbox', who.org ? { org_role: who.role } : {}), body }) + let n = 0 + const create = async (who: Who, extra: Record = {}) => { + n += 1 + const res = await req(who, 'POST', '/v1/sandboxes', { workspaceId: `ws-${n}`, machineSize: 'standard', ...extra }) + expect(res.status).toBe(200) + return res.body.sandbox.id as string + } + const alice: Who = { sub: 'alice', org: 'acme', role: 'member' } + const bob: Who = { sub: 'bob', org: 'acme', role: 'member' } + const admin: Who = { sub: 'carol', org: 'acme', role: 'admin' } + const eve: Who = { sub: 'eve', org: 'other', role: 'owner' } + const solo: Who = { sub: 'sam', role: 'member' } + return { h, req, create, alice, bob, admin, eve, solo } +} + +describe('workspace numbers (W-123)', () => { + it('numbers workspaces per account and never reuses a number', async () => { + const t = await setup() + const a1 = await t.create(t.alice) + const a2 = await t.create(t.bob, { visibility: 'team' }) + const e1 = await t.create(t.eve) + const view = async (who: Who, id: string) => (await t.req(who, 'GET', `/v1/team/workspaces/${id}`)).body.workspace + expect((await view(t.alice, a1)).number).toBe(1) + expect((await view(t.bob, a2)).number).toBe(2) + expect((await view(t.eve, e1)).number).toBe(1) + expect((await t.req(t.alice, 'DELETE', `/v1/sandboxes/${a1}`)).status).toBe(200) + const a3 = await t.create(t.alice) + expect((await view(t.alice, a3)).number).toBe(3) + }) + + it('backfills existing rows by creation order and seeds the counter', () => { + const raw = new DatabaseSync(':memory:') + const dir = fileURLToPath(new URL('../migrations/', import.meta.url).href) + const files = readdirSync(dir).filter((f) => f.endsWith('.sql')).sort() + const at = files.indexOf('0051_workspace_numbers_prefs.sql') + for (const file of files.slice(0, at)) { + raw.exec(readFileSync(`${dir}${file}`, 'utf8')) + } + const insert = raw.prepare( + `INSERT INTO sandboxes (id, account_id, user_id, workspace_id, provider, provider_name, status, machine_size, region, + generation, created_at, updated_at) VALUES (?, ?, 'u', ?, 'vercel', ?, 'destroyed', 'standard', 'iad1', 0, ?, ?)` + ) + insert.run('sbx_b', 'org:a', 'w2', 'p2', 20, 20) + insert.run('sbx_a', 'org:a', 'w1', 'p1', 10, 10) + insert.run('sbx_c', 'org:a', 'w3', 'p3', 20, 20) + insert.run('sbx_z', 'org:b', 'w1', 'pz', 5, 5) + for (const file of files.slice(at)) { + raw.exec(readFileSync(`${dir}${file}`, 'utf8')) + } + expect(raw.prepare('SELECT id, number FROM sandboxes ORDER BY id').all()).toEqual([ + { id: 'sbx_a', number: 1 }, + { id: 'sbx_b', number: 2 }, + { id: 'sbx_c', number: 3 }, + { id: 'sbx_z', number: 1 } + ]) + expect(raw.prepare('SELECT * FROM org_workspace_counters ORDER BY account_id').all()).toEqual([ + { account_id: 'org:a', last_number: 3 }, + { account_id: 'org:b', last_number: 1 } + ]) + }) +}) + +describe('org slugs', () => { + it('slugifies names and refuses reserved or malformed slugs', () => { + expect(slugify('Acme Labs, Inc.')).toBe('acme-labs-inc') + expect(slugify('Ünïcode Crew')).toBe('unicode-crew') + expect(slugify('!!!')).toBe('team') + expect(slugify('w')).toBe('w-team') + expect(isValidSlug('acme')).toBe(true) + expect(isValidSlug('w')).toBe(false) + expect(isValidSlug('-acme')).toBe(false) + expect(isValidSlug('a--b')).toBe(false) + expect(isValidSlug('Acme')).toBe(false) + }) + + it('names an org once from the first name it hears, uniquely across orgs', async () => { + const t = await setup() + expect((await t.req(t.alice, 'GET', '/v1/team/org')).body).toEqual({ slug: null, orgId: 'acme' }) + expect((await t.req(t.alice, 'GET', '/v1/team/org?name=Acme%20Labs')).body).toEqual({ slug: 'acme-labs', orgId: 'acme' }) + // A teammate whose client shows another name still gets the org's slug. + expect((await t.req(t.bob, 'GET', '/v1/team/org?name=Whatever')).body.slug).toBe('acme-labs') + expect((await t.req(t.eve, 'GET', '/v1/team/org?name=Acme%20Labs')).body.slug).toBe('acme-labs-2') + expect((await t.req(t.solo, 'GET', '/v1/team/org?name=Sam')).body).toEqual({ slug: null, orgId: null }) + }) + + it('lets only admins rename, and not onto another org', async () => { + const t = await setup() + await t.req(t.alice, 'GET', '/v1/team/org?name=Acme') + await t.req(t.eve, 'GET', '/v1/team/org?name=Other') + expect((await t.req(t.alice, 'PUT', '/v1/team/org', { slug: 'acme-co' })).status).toBe(403) + expect((await t.req(t.admin, 'PUT', '/v1/team/org', { slug: 'other' })).status).toBe(409) + expect((await t.req(t.admin, 'PUT', '/v1/team/org', { slug: 'w' })).status).toBe(400) + expect((await t.req(t.admin, 'PUT', '/v1/team/org', { slug: 'acme-co' })).body).toEqual({ slug: 'acme-co', orgId: 'acme' }) + expect((await t.req(t.bob, 'GET', '/v1/team/org')).body.slug).toBe('acme-co') + }) +}) + +describe('slug links', () => { + it('copies org slug links and resolves them only for those who can see the workspace', async () => { + const t = await setup() + const id = await t.create(t.alice) + const before = (await t.req(t.alice, 'GET', `/v1/team/workspaces/${id}`)).body.workspace + // No slug yet: the id form still works. + expect(before.link).toBe(`orca://cloud/w/${id}`) + await t.req(t.alice, 'GET', '/v1/team/org?name=Acme') + const after = (await t.req(t.alice, 'GET', '/v1/team/workspaces?scope=mine')).body.workspaces[0] + expect(after.link).toBe('orca://cloud/acme/W-1') + + const resolved = await t.req(t.alice, 'GET', '/v1/team/links/resolve?org=acme&n=1&c=s:abc') + expect(resolved.status).toBe(200) + expect(resolved.body).toMatchObject({ workspace: { id, number: 1 }, chatId: 's:abc' }) + // Private to Alice: Bob sees nothing until she shares it. + expect((await t.req(t.bob, 'GET', '/v1/team/links/resolve?org=acme&n=1')).status).toBe(404) + await t.req(t.alice, 'PATCH', `/v1/team/workspaces/${id}`, { visibility: 'team' }) + expect((await t.req(t.bob, 'GET', '/v1/team/links/resolve?org=acme&n=1')).body.workspace.id).toBe(id) + expect((await t.req(t.bob, 'GET', '/v1/team/links/resolve?org=acme&n=2')).status).toBe(404) + // Another org: not found, but says which org so a member of both can switch. + const other = await t.req(t.eve, 'GET', '/v1/team/links/resolve?org=acme&n=1') + expect(other.status).toBe(404) + expect(other.body).toEqual({ error: 'not_found', reason: 'other_org', orgId: 'acme' }) + expect((await t.req(t.eve, 'GET', '/v1/team/links/resolve?org=nope&n=1')).body).toEqual({ error: 'not_found' }) + expect((await t.req(t.alice, 'GET', '/v1/team/links/resolve?org=acme&n=0')).status).toBe(400) + }) +}) + +describe('workspace prefs (synced pins and order)', () => { + const A = `sbx_${'a'.repeat(24)}` + const B = `sbx_${'b'.repeat(24)}` + + it('stores one document per member and account with compare-and-set', async () => { + const t = await setup() + expect((await t.req(t.alice, 'GET', '/v1/team/prefs')).body).toEqual({ + document: { pinned: [], order: [], sections: [], collapsed: [] }, + revision: 0, + updatedAt: null + }) + const doc = { pinned: [A], order: [B], sections: ['Auth', 'Billing'], collapsed: ['Billing'] } + const first = await t.req(t.alice, 'PUT', '/v1/team/prefs', { document: doc, revision: 0, deviceId: 'desk-1' }) + expect(first.status).toBe(200) + expect(first.body).toMatchObject({ document: doc, revision: 1 }) + // A second device that still holds revision 0 must re-read before writing. + const stale = await t.req(t.alice, 'PUT', '/v1/team/prefs', { document: { ...doc, pinned: [] }, revision: 0 }) + expect(stale.status).toBe(409) + const second = await t.req(t.alice, 'PUT', '/v1/team/prefs', { document: { ...doc, pinned: [B, A], order: [] }, revision: 1 }) + expect(second.body.revision).toBe(2) + expect((await t.req(t.alice, 'GET', '/v1/team/prefs')).body.document.pinned).toEqual([B, A]) + // Teammates and other accounts have their own. + expect((await t.req(t.bob, 'GET', '/v1/team/prefs')).body.revision).toBe(0) + expect((await t.req({ ...t.alice, org: 'other' }, 'GET', '/v1/team/prefs')).body.revision).toBe(0) + expect((await t.req(t.solo, 'PUT', '/v1/team/prefs', { document: doc, revision: 0 })).status).toBe(200) + }) + + it('rejects malformed documents', async () => { + const t = await setup() + const put = (document: unknown) => t.req(t.alice, 'PUT', '/v1/team/prefs', { document, revision: 0 }) + expect((await put({ pinned: [A], order: [A], sections: [], collapsed: [] })).status).toBe(400) + expect((await put({ pinned: [A, A], order: [], sections: [], collapsed: [] })).status).toBe(400) + expect((await put({ pinned: ['nope'], order: [], sections: [], collapsed: [] })).status).toBe(400) + expect((await put({ pinned: [], order: [], sections: ['x'], collapsed: [], extra: 1 })).status).toBe(400) + }) +}) diff --git a/cloud/apps/sandbox-control/test/workspaces.test.ts b/cloud/apps/sandbox-control/test/workspaces.test.ts index 7b090930f83..881006ae296 100644 --- a/cloud/apps/sandbox-control/test/workspaces.test.ts +++ b/cloud/apps/sandbox-control/test/workspaces.test.ts @@ -66,6 +66,35 @@ describe('workspace registry', () => { expect((await t.req(stranger, 'GET', `/v1/team/links/resolve?w=${t.id}`)).status).toBe(404) }) + it('keeps routine runs off Home unless the Routine runs filter asks for them', async () => { + const t = await team() + // A routine run's VM: hidden and tagged with its routine (what routines/runs.ts creates). + expect((await t.req(t.alice, 'GET', '/v1/team/workspaces?scope=mine')).body.routineRuns).toEqual({ routines: 0, hidden: 0, hiddenRunning: 0, hiddenComputeMs: 0 }) + t.h.raw + .prepare( + `INSERT INTO routines (id, account_id, created_by, name, project_id, trigger_kind, trigger_config, agent, prompt, max_runtime_ms, created_at, updated_at) + VALUES ('rtn_1', 'org:acme', 'alice', 'nightly-deps', 'prj_1', 'webhook', '{}', 'claude', 'x', 60000, 0, 0)` + ) + .run() + t.h.raw.prepare(`UPDATE sandboxes SET hidden = 1, origin = 'routine', origin_ref = 'rtn_1' WHERE id = ?`).run(t.id) + const off = await t.req(t.alice, 'GET', '/v1/team/workspaces?scope=mine') + expect(off.body.workspaces).toEqual([]) + // What the switch hides is still counted for Home: the switch label and the team's hours. + expect(off.body.routineRuns).toMatchObject({ routines: 1, hidden: 1, hiddenRunning: 1 }) + const shown = await t.req(t.alice, 'GET', '/v1/team/workspaces?scope=mine&routines=include') + expect(shown.body.workspaces.map((w: { id: string; fromRoutine: boolean; routineName: string }) => [w.id, w.fromRoutine, w.routineName])).toEqual([ + [t.id, true, 'nightly-deps'] + ]) + expect(shown.body.routineRuns).toMatchObject({ routines: 1, hidden: 0, hiddenRunning: 0 }) + // Other machine-made rows stay hidden even then. + t.h.raw.prepare(`UPDATE sandboxes SET origin = 'vm' WHERE id = ?`).run(t.id) + expect((await t.req(t.alice, 'GET', '/v1/team/workspaces?scope=mine&routines=include')).body.workspaces).toEqual([]) + // A plain workspace says so. + t.h.raw.prepare(`UPDATE sandboxes SET hidden = 0, origin = 'desktop' WHERE id = ?`).run(t.id) + expect((await t.req(t.alice, 'GET', '/v1/team/workspaces?scope=mine')).body.workspaces[0].fromRoutine).toBe(false) + expect((await t.req(t.alice, 'GET', '/v1/team/workspaces?routines=bogus')).status).toBe(400) + }) + it('lets admins see private rows for management (scope=all) without access', async () => { const t = await team() expect((await t.req(t.bob, 'GET', '/v1/team/workspaces?scope=all')).status).toBe(403) @@ -414,7 +443,7 @@ describe('desktop wire contract', () => { ).body ) wire.CloudWorkspaceGrantListSchema.parse((await t.req(t.bob, 'GET', `/v1/team/workspaces/${t.id}/grants`)).body) - expect(wire.parseCloudWorkspaceLink(wire.cloudWorkspaceLink(t.id, 'chat 1'))).toEqual({ workspaceId: t.id, chatId: 'chat 1' }) + expect(wire.parseCloudWorkspaceLink(wire.cloudWorkspaceLink(t.id, 'chat 1'))).toEqual({ target: { kind: 'id', workspaceId: t.id }, chatId: 'chat 1' }) expect(issued.grant.status).toBe('active') }) diff --git a/config/localization-coverage-allowlist.json b/config/localization-coverage-allowlist.json index abfae50fd7f..d6960e64ae5 100644 --- a/config/localization-coverage-allowlist.json +++ b/config/localization-coverage-allowlist.json @@ -188,6 +188,13 @@ "dynamic": false, "count": 1 }, + { + "filePath": "src/renderer/src/lib/workspace/search/worktrees/worktree-palette-evidence.ts", + "kind": "object-property:accessibilityLabel", + "text": "Cloud workspace number", + "dynamic": false, + "count": 1 + }, { "filePath": "src/renderer/src/components/agent/launch-settings/AgentDefaultSurfacePreviews.tsx", "kind": "jsx-attribute:title", diff --git a/config/main-sync-fs-baseline.txt b/config/main-sync-fs-baseline.txt index ff125bd74d6..107660aeac1 100644 --- a/config/main-sync-fs-baseline.txt +++ b/config/main-sync-fs-baseline.txt @@ -14,7 +14,7 @@ 14 src/main/agent-launch/trust/agent-trust-presets.ts 2 src/main/agent-launch/trust/antigravity-workspace-trust-ownership.ts 1 src/main/agent-launch/trust/execution-host-workspace-trust.ts -2 src/main/agent-mcp-sync/desktop/cloud-mcp-sync.ts +1 src/main/agent-mcp-sync/desktop/cloud-mcp-sync.ts 1 src/main/ai-vault-search/session-search-worker-client.ts 4 src/main/ai-vault/parse-cache/session-parse-cache-legacy-json.ts 2 src/main/ai-vault/scan-service/session-scanner-service-entry-path.ts @@ -54,6 +54,7 @@ 5 src/main/browser/cookies/sources/browser-cookie-source-profiles.ts 11 src/main/browser/cookies/staging/browser-session-cookie-staging.ts 1 src/main/browser/downloads/browser-download-destination.ts +2 src/main/browser/electron-fixtures/popup-identity-electron-probe.ts 2 src/main/browser/extensions/api-runtime/browser-extension-worker-shim-source.ts 8 src/main/browser/extensions/installation/browser-extension-install-store.ts 1 src/main/browser/extensions/installation/browser-extension-load-directory.ts @@ -63,7 +64,6 @@ 4 src/main/browser/extensions/profile-storage/browser-extension-profile-state-store.ts 3 src/main/browser/extensions/profile-storage/browser-extension-retired-profile-storage.ts 1 src/main/browser/guest-lifecycle/popups/compatibility/browser-popup-background-cdp-probe.ts -2 src/main/browser/electron-fixtures/popup-identity-electron-probe.ts 1 src/main/browser/identity/mode/browser-identity-mode-record.ts 2 src/main/browser/identity/mode/browser-identity-mode-store.ts 2 src/main/browser/network/egress/browser-route-egress-electron-launch.ts @@ -117,7 +117,6 @@ 1 src/main/codex-accounts/codex-login-auth-snapshot.ts 5 src/main/codex-accounts/codex-managed-home-lifecycle.ts 6 src/main/codex-accounts/codex-managed-home-path.ts -17 src/main/filesystem/atomic-file-publication.ts 1 src/main/codex-accounts/guest-codex-account-homes.ts 6 src/main/codex-accounts/host-codex-managed-home-ownership.ts 2 src/main/codex-accounts/legacy-shared-auth-migration.ts @@ -247,6 +246,7 @@ 7 src/main/emulator/serve-sim-execution.ts 17 src/main/emulator/serve-sim-runtime-materializer.ts 12 src/main/external-editors/external-editor-launch.ts +17 src/main/filesystem/atomic-file-publication.ts 9 src/main/filesystem/durable-file-write.ts 2 src/main/filesystem/rolling-file-backup.ts 2 src/main/foreign-sqlite-readers/foreign-sqlite-reader-entry-path.ts @@ -297,6 +297,7 @@ 13 src/main/kimi/hook-service.ts 3 src/main/kiro/hook-service.ts 1 src/main/kiro/standalone-hooks.ts +3 src/main/lib/hidden-probe-cwd.ts 4 src/main/linear/linear-credential-paths.ts 3 src/main/linear/linear-legacy-viewer-store.ts 1 src/main/linear/linear-token-store.ts @@ -465,7 +466,6 @@ 1 src/main/qoder/workspace-trust.ts 4 src/main/rate-limits/providers/cursor/cursor-auth.ts 2 src/main/rate-limits/providers/grok/grok-auth.ts -3 src/main/lib/hidden-probe-cwd.ts 2 src/main/rate-limits/providers/opencode-go/opencode-go-api-key-source.ts 1 src/main/rate-limits/providers/zcode/zcode-usage-credentials.ts 3 src/main/ripgrep/bundled-ripgrep-path.ts diff --git a/mobile/app/_layout.tsx b/mobile/app/_layout.tsx index 494a66abf56..28090cb988c 100644 --- a/mobile/app/_layout.tsx +++ b/mobile/app/_layout.tsx @@ -230,6 +230,7 @@ export default function RootLayout() { + /W-123, the desktop's "Copy link") open here. */ +export default function CloudWorkspaceNumberLinkRoute() { + const t = useMobileTranslation() + const router = useRouter() + const params = useLocalSearchParams<{ org?: string; number?: string }>() + const link = `orca://cloud/${params.org ?? ''}/${params.number ?? ''}` + const [resolved, setResolved] = useState({ kind: 'loading' }) + useEffect(() => { + let live = true + const parsed = parseCloudWorkspaceLink(link) + void (async () => { + const plane = parsed ? await loadCloudControlPlane() : null + const sandboxId = + plane && parsed ? await resolveCloudWorkspaceLink(plane, parsed.target) : null + if (live) { + setResolved(sandboxId ? { kind: 'found', sandboxId } : { kind: 'missing' }) + } + })().catch(() => live && setResolved({ kind: 'missing' })) + return () => { + live = false + } + }, [link]) + if (resolved.kind === 'found') { + return + } + return ( + + {resolved.kind === 'loading' ? ( + + ) : ( + router.replace('/') }} + /> + )} + + ) +} diff --git a/mobile/src/cloud/CloudWorkspaceActions.tsx b/mobile/src/cloud/CloudWorkspaceActions.tsx index fd876698b39..1ff6df5822b 100644 --- a/mobile/src/cloud/CloudWorkspaceActions.tsx +++ b/mobile/src/cloud/CloudWorkspaceActions.tsx @@ -1,4 +1,4 @@ -import { Archive, Moon } from 'lucide-react-native' +import { Archive, Moon, Pin, PinOff } from 'lucide-react-native' import { useState } from 'react' import { View } from 'react-native' import { ConfirmModal } from '../components/ConfirmModal' @@ -8,6 +8,41 @@ import { colors } from '../theme/mobile-theme' import { useMobileColorScheme } from '../theme/use-mobile-color-scheme' import type { CloudWorkspace } from './cloud-control-plane-client' import { cloudWorkspaceScreenStyles as styles } from './cloud-workspace-screen-styles' +import { useCloudWorkspacePrefs } from './cloud-workspace-prefs' +import { useCloudEnrollment } from './use-cloud-workspaces' +import { setPinned } from '../../../src/shared/cloud-workspaces/cloud-workspace-arrangement' + +/** Pin to the top of the Cloud list on every device of yours (your own pins, not the team's). */ +function CloudWorkspacePinRow(props: { workspace: CloudWorkspace }) { + const t = useMobileTranslation() + const enrollment = useCloudEnrollment() + const prefs = useCloudWorkspacePrefs(enrollment?.deviceSessionId ?? null) + const [busy, setBusy] = useState(false) + if (!enrollment || props.workspace.status === 'archived') { + return null + } + const pinned = prefs.document.pinned.includes(props.workspace.id) + const Icon = pinned ? PinOff : Pin + return ( + + + } + title={pinned ? t('cloud.home.unpin', 'Unpin') : t('cloud.home.pin', 'Pin to top')} + subtitle={t('cloud.actions.pinCaption', 'On all your devices. Only you see your pins.')} + busy={busy} + onPress={() => { + setBusy(true) + void prefs + .edit((doc) => setPinned(doc, props.workspace.id, !pinned)) + .finally(() => setBusy(false)) + }} + /> + + + ) +} /** Sleep (no sandbox hours, files kept) and Archive, each behind a confirm because both stop agents. */ export function CloudWorkspaceActions(props: { @@ -29,6 +64,7 @@ export function CloudWorkspaceActions(props: { const running = props.workspace.status === 'running' return ( <> + {running ? ( diff --git a/mobile/src/cloud/cloud-control-plane-client.ts b/mobile/src/cloud/cloud-control-plane-client.ts index 33043dc67d0..529e76670b7 100644 --- a/mobile/src/cloud/cloud-control-plane-client.ts +++ b/mobile/src/cloud/cloud-control-plane-client.ts @@ -47,6 +47,9 @@ export type CloudWorkspace = { createdByUserId: string | null /** When the last sleeping read snapshot was stored (ms); null when none or unknown. */ readSnapshotAt: number | null + /** Its number in the account (W-123); absent on older control planes and the owner-only list. */ + number?: number | null + section?: string | null } const SANDBOX_STATUS: Record = { creating: 'creating', @@ -99,7 +102,9 @@ function fromRegistry(row: TeamWorkspace): CloudWorkspace { lastActivityAt: row.lastActivityAt, sandboxMs: row.cost.computeMs, createdByUserId: row.createdBy, - readSnapshotAt: row.readSnapshotAt ?? null + readSnapshotAt: row.readSnapshotAt ?? null, + number: row.number ?? null, + section: row.section } } diff --git a/mobile/src/cloud/cloud-workspace-prefs.test.ts b/mobile/src/cloud/cloud-workspace-prefs.test.ts new file mode 100644 index 00000000000..3e835be9771 --- /dev/null +++ b/mobile/src/cloud/cloud-workspace-prefs.test.ts @@ -0,0 +1,83 @@ +import { describe, expect, it, vi } from 'vitest' +import { z } from 'zod' + +vi.mock('./cloud-session', () => ({ loadCloudControlPlane: vi.fn() })) + +import { setPinned } from '../../../src/shared/cloud-workspaces/cloud-workspace-arrangement' +import { editCloudWorkspacePrefsOn, resolveCloudWorkspaceLink } from './cloud-workspace-prefs' +import type { CloudControlPlane } from './cloud-control-plane-request' + +const PutBody = z.object({ + document: z.object({ + pinned: z.array(z.string()), + order: z.array(z.string()), + sections: z.array(z.string()), + collapsed: z.array(z.string()) + }), + revision: z.number() +}) + +const A = `sbx_${'a'.repeat(24)}` +const B = `sbx_${'b'.repeat(24)}` + +function plane(handler: (method: string, url: URL, body: unknown) => [number, unknown]) { + const calls: string[] = [] + const fetchFn: typeof fetch = async (input, init = {}) => { + const url = new URL(String(input)) + calls.push(`${init.method} ${url.pathname}${url.search}`) + const [status, body] = handler( + init.method ?? 'GET', + url, + init.body ? JSON.parse(String(init.body)) : undefined + ) + return new Response(JSON.stringify(body), { status }) + } + const p: CloudControlPlane = { baseUrl: 'https://cp.example', token: () => 't', fetch: fetchFn } + return { plane: p, calls } +} + +describe('phone prefs sync', () => { + it('re-applies a pin on top of a desktop that wrote first', async () => { + let server: z.infer = { + document: { pinned: [B], order: [], sections: [], collapsed: [] }, + revision: 3 + } + let firstPut = true + const { plane: p, calls } = plane((method, _url, body) => { + if (method === 'GET') { + return [200, { ...server, updatedAt: 1 }] + } + const put = PutBody.parse(body) + if (firstPut) { + // A desktop wrote between our read and our write. + firstPut = false + server = { ...server, revision: 4 } + return [409, { error: 'conflict', reason: 'stale_revision' }] + } + expect(put.revision).toBe(4) + server = { document: put.document, revision: 5 } + return [200, { ...server, updatedAt: 2 }] + }) + const saved = await editCloudWorkspacePrefsOn(p, (doc) => setPinned(doc, A, true)) + expect(saved.document.pinned).toEqual([B, A]) + expect(calls).toEqual([ + 'GET /v1/team/prefs', + 'PUT /v1/team/prefs', + 'GET /v1/team/prefs', + 'PUT /v1/team/prefs' + ]) + }) + + it('resolves number links and treats not found as null', async () => { + const { plane: p, calls } = plane((_method, url) => + url.searchParams.get('n') === '7' + ? [200, { workspace: { id: A }, chatId: null }] + : [404, { error: 'not_found' }] + ) + await expect( + resolveCloudWorkspaceLink(p, { kind: 'number', org: 'acme', number: 8 }) + ).resolves.toBeNull() + expect(calls).toEqual(['GET /v1/team/links/resolve?org=acme&n=8']) + await expect(resolveCloudWorkspaceLink(p, { kind: 'id', workspaceId: B })).resolves.toBe(B) + }) +}) diff --git a/mobile/src/cloud/cloud-workspace-prefs.ts b/mobile/src/cloud/cloud-workspace-prefs.ts new file mode 100644 index 00000000000..fd2259d8e0f --- /dev/null +++ b/mobile/src/cloud/cloud-workspace-prefs.ts @@ -0,0 +1,125 @@ +// The phone's side of synced cloud workspace prefs (/v1/team/prefs): the same pins and order as +// the member's desktops, read and written with the phone's own device-signed token, and W-number +// links (orca://cloud//W-123) resolved to a workspace. +import { useQuery, useQueryClient } from '@tanstack/react-query' +import { useCallback } from 'react' +import { + CloudWorkspaceLinkResponseSchema, + CloudWorkspacePrefsSchema, + EMPTY_CLOUD_WORKSPACE_PREFS, + type CloudWorkspaceLinkTarget, + type CloudWorkspacePrefs, + type CloudWorkspacePrefsDocument +} from '../../../src/shared/cloud-workspaces/cloud-workspaces-wire' +import { + CloudRequestError, + cloudRequest as request, + type CloudControlPlane +} from './cloud-control-plane-request' +import { loadCloudControlPlane } from './cloud-session' + +const MAX_ATTEMPTS = 4 + +export function getCloudWorkspacePrefs( + plane: CloudControlPlane, + signal?: AbortSignal +): Promise { + return request(plane, 'GET', '/v1/team/prefs', CloudWorkspacePrefsSchema, { signal }) +} + +/** + * Applies `edit` to the newest server copy and writes it with compare-and-set; when a desktop wrote + * first it re-reads and applies the same edit again. + */ +export async function editCloudWorkspacePrefsOn( + plane: CloudControlPlane, + edit: (doc: CloudWorkspacePrefsDocument) => CloudWorkspacePrefsDocument +): Promise { + let current = await getCloudWorkspacePrefs(plane) + for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) { + const next = edit(current.document) + if (next === current.document) { + return current + } + try { + return await request(plane, 'PUT', '/v1/team/prefs', CloudWorkspacePrefsSchema, { + body: { document: next, revision: current.revision } + }) + } catch (error) { + if (!(error instanceof CloudRequestError) || error.code !== 'conflict') { + throw error + } + current = await getCloudWorkspacePrefs(plane) + } + } + throw new CloudRequestError('conflict', 409, 'stale_revision') +} + +/** Either link form → the workspace's sandbox id (null when this account can't see it). */ +export async function resolveCloudWorkspaceLink( + plane: CloudControlPlane, + target: CloudWorkspaceLinkTarget +): Promise { + if (target.kind === 'id') { + return target.workspaceId + } + const params = new URLSearchParams({ org: target.org, n: String(target.number) }) + try { + const body = await request( + plane, + 'GET', + `/v1/team/links/resolve?${params}`, + CloudWorkspaceLinkResponseSchema + ) + return body.workspace.id + } catch (error) { + if (error instanceof CloudRequestError && error.status === 404) { + return null + } + throw error + } +} + +export const cloudWorkspacePrefsQueryKey = (sessionId: string | null) => + ['orca-cloud', 'prefs', sessionId] as const + +/** This member's synced prefs and an edit that saves them (shown at once, rolled back on failure). */ +export function useCloudWorkspacePrefs(sessionId: string | null) { + const client = useQueryClient() + const query = useQuery({ + queryKey: cloudWorkspacePrefsQueryKey(sessionId), + enabled: sessionId !== null, + queryFn: async ({ signal }) => { + const plane = await loadCloudControlPlane() + return plane + ? (await getCloudWorkspacePrefs(plane, signal)).document + : EMPTY_CLOUD_WORKSPACE_PREFS + }, + // Desktops edit it too; pick their edits up whenever Home is in front. + refetchInterval: 15_000, + staleTime: 5_000 + }) + const edit = useCallback( + async (change: (doc: CloudWorkspacePrefsDocument) => CloudWorkspacePrefsDocument) => { + const key = cloudWorkspacePrefsQueryKey(sessionId) + const previous = client.getQueryData(key) + client.setQueryData(key, (doc) => + change(doc ?? EMPTY_CLOUD_WORKSPACE_PREFS) + ) + try { + const plane = await loadCloudControlPlane() + if (!plane) { + throw new CloudRequestError('not_enrolled', 0) + } + const saved = await editCloudWorkspacePrefsOn(plane, change) + client.setQueryData(key, saved.document) + return true + } catch { + client.setQueryData(key, previous) + return false + } + }, + [client, sessionId] + ) + return { document: query.data ?? EMPTY_CLOUD_WORKSPACE_PREFS, edit } +} diff --git a/mobile/src/home/MobileHomeCloudSection.tsx b/mobile/src/home/MobileHomeCloudSection.tsx index 66b154f6125..a6d73053710 100644 --- a/mobile/src/home/MobileHomeCloudSection.tsx +++ b/mobile/src/home/MobileHomeCloudSection.tsx @@ -1,7 +1,7 @@ import { useRouter } from 'expo-router' -import { ChevronRight, Cloud, Plus, RotateCw } from 'lucide-react-native' -import { Fragment, useState } from 'react' -import { ActivityIndicator, Pressable, Text, View } from 'react-native' +import { ChevronRight, Cloud, Pin, Plus, RotateCw } from 'lucide-react-native' +import { Fragment, useMemo, useState } from 'react' +import { ActivityIndicator, Alert, Pressable, Text, View } from 'react-native' import { CloudStatusDot } from '../cloud/CloudStatusDot' import { formatReadSnapshotAsOf } from '../cloud/CloudReadSnapshotSection' import type { CloudWorkspace } from '../cloud/cloud-control-plane-client' @@ -10,6 +10,12 @@ import { takeCloudReturnTo } from '../cloud/cloud-return-to' import type { CloudEnrollment } from '../cloud/cloud-device-identity' import { cloudRepoLine, cloudStatusLabel } from '../cloud/cloud-workspace-display' import { useCloudWorkspaces } from '../cloud/use-cloud-workspaces' +import { useCloudWorkspacePrefs } from '../cloud/cloud-workspace-prefs' +import { + arrangeCloudWorkspaces, + setPinned +} from '../../../src/shared/cloud-workspaces/cloud-workspace-arrangement' +import { formatWorkspaceNumber } from '../../../src/shared/cloud-workspaces/cloud-workspaces-wire' import { formatTimeAgo } from '../worktree/agent-row-display' import { useMobileTranslation } from '../i18n/use-mobile-translation' import { colors } from '../theme/mobile-theme' @@ -35,13 +41,43 @@ export function MobileHomeCloudSection(props: { const t = useMobileTranslation() useMobileColorScheme() const query = useCloudWorkspaces(props.enrollment) + // Pins and order are the member's own and sync with their desktops. + const prefs = useCloudWorkspacePrefs(props.enrollment?.deviceSessionId ?? null) + const workspaces = useMemo( + () => + arrangeCloudWorkspaces( + (query.data ?? []).filter((workspace) => workspace.status !== 'archived'), + prefs.document + ).flatMap((group) => + group.rows.map((workspace) => ({ workspace, pinned: group.kind === 'pinned' })) + ), + [query.data, prefs.document] + ) if (props.enrollment === undefined) { return null } if (props.enrollment === null) { return } - const workspaces = (query.data ?? []).filter((workspace) => workspace.status !== 'archived') + const togglePin = (workspace: CloudWorkspace, pinned: boolean) => { + Alert.alert(workspace.title, undefined, [ + { + text: pinned ? t('cloud.home.unpin', 'Unpin') : t('cloud.home.pin', 'Pin to top'), + onPress: () => + void prefs + .edit((doc) => setPinned(doc, workspace.id, !pinned)) + .then((saved) => { + if (!saved) { + Alert.alert( + t('cloud.home.pinFailed', 'Couldn’t save that change'), + t('cloud.home.pinFailedDetail', 'Check your connection and try again.') + ) + } + }) + }, + { text: t('common.cancel', 'Cancel'), style: 'cancel' } + ]) + } const now = query.dataUpdatedAt || 0 return ( <> @@ -94,12 +130,14 @@ export function MobileHomeCloudSection(props: { ) : ( - workspaces.map((workspace) => ( + workspaces.map(({ workspace, pinned }) => ( props.onOpenWorkspace(workspace)} + onLongPress={() => togglePin(workspace, pinned)} /> @@ -135,12 +173,16 @@ function SkeletonRow() { function CloudWorkspaceRow({ workspace, + pinned, now, - onPress + onPress, + onLongPress }: { workspace: CloudWorkspace + pinned: boolean now: number onPress: () => void + onLongPress: () => void }) { const t = useMobileTranslation() const status = cloudStatusLabel(workspace.status, t) @@ -175,7 +217,9 @@ function CloudWorkspaceRow({ : createdLine && lastActive - workspace.createdAt < 60_000 ? null : formatTimeAgo(lastActive, reference) - const line = [status, detail, when].filter(Boolean).join(' · ') + const number = workspace.number ? formatWorkspaceNumber(workspace.number) : null + const line = [status, number, detail, when].filter(Boolean).join(' · ') + const optionsLabel = pinned ? t('cloud.home.unpin', 'Unpin') : t('cloud.home.pin', 'Pin to top') return ( { + if (event.nativeEvent.actionName === 'longpress') { + onLongPress() + } + }} style={({ pressed }) => [styles.row, pressed && styles.rowPressed]} onPress={onPress} + onLongPress={onLongPress} + delayLongPress={400} > @@ -204,13 +257,14 @@ function CloudWorkspaceRow({ {status} - {[detail, when] + {[number, detail, when] .filter(Boolean) .map((part) => ` · ${part}`) .join('')} + {pinned ? : null} diff --git a/mobile/src/i18n/locales/en.json b/mobile/src/i18n/locales/en.json index d3411f6ac91..584bf445524 100644 --- a/mobile/src/i18n/locales/en.json +++ b/mobile/src/i18n/locales/en.json @@ -5020,7 +5020,8 @@ "actions": { "sleep": "Sleep", "sleepCaption": "Sandbox hours stop. Files are kept; agents restart when it wakes.", - "archive": "Archive" + "archive": "Archive", + "pinCaption": "On all your devices. Only you see your pins." }, "sleep": { "title": "Sleep {{title}}?", @@ -5122,7 +5123,12 @@ "new": "New cloud workspace", "createdAgo": "Created {{ago}} ago", "createdJustNow": "Created just now", - "workspaceRowLabel": "Cloud workspace, {{title}}, {{detail}}" + "workspaceRowLabel": "Cloud workspace, {{title}}, {{detail}}", + "unpin": "Unpin", + "pin": "Pin to top", + "pinFailed": "Couldn’t save that change", + "pinFailedDetail": "Check your connection and try again.", + "pinnedHint": "Pinned" }, "connect": { "signedOut": "Sign in to Orca on {{desktop}}, then try again.", @@ -5231,6 +5237,12 @@ "idle": { "sleeps_one": "Sleeps after {{count}} minute idle.", "sleeps_other": "Sleeps after {{count}} minutes idle." + }, + "link": { + "opening": "Opening workspace…", + "missingTitle": "Can’t open this workspace", + "missing": "It’s private, in another team, or deleted. If it’s in another team, switch to it on your computer first.", + "home": "Go to Home" } } } diff --git a/src/main/agent-config-sync/agent-config-digest.ts b/src/main/agent-config-sync/agent-config-digest.ts new file mode 100644 index 00000000000..798d38cd28a --- /dev/null +++ b/src/main/agent-config-sync/agent-config-digest.ts @@ -0,0 +1,21 @@ +import { createHash } from 'node:crypto' + +export type AgentConfigDigestEntry = { + /** Relative path inside a skill folder, or `.` for a command file. */ + path: string + executable: boolean + bytes: Buffer +} + +/** Content identity of one item. Desktop and host compute it the same way, so either side can tell + * whether a sandbox copy is exactly what this computer sent. */ +export function agentConfigDigest(entries: readonly AgentConfigDigestEntry[]): string { + const hash = createHash('sha256') + for (const entry of [...entries].sort((a, b) => + a.path < b.path ? -1 : a.path > b.path ? 1 : 0 + )) { + const body = createHash('sha256').update(entry.bytes).digest('hex') + hash.update(`${entry.path}\0${entry.executable ? 1 : 0}\0${body}\n`) + } + return hash.digest('hex') +} diff --git a/src/main/agent-config-sync/agent-config-roots.ts b/src/main/agent-config-sync/agent-config-roots.ts new file mode 100644 index 00000000000..a97863805b8 --- /dev/null +++ b/src/main/agent-config-sync/agent-config-roots.ts @@ -0,0 +1,69 @@ +import { homedir } from 'node:os' +import { join } from 'node:path' +import type { + AgentConfigItemKind, + AgentConfigItemScope +} from '../../shared/agent-config-sync/agent-config-sync-contract' +import { AGENT_CONFIG_FILE_KINDS } from '../../shared/agent-config-sync/agent-config-sync-contract' + +export type AgentConfigHomes = { + /** Claude Code's config dir: $CLAUDE_CONFIG_DIR or ~/.claude. */ + claudeDir: string + /** $CODEX_HOME or ~/.codex. */ + codexDir: string + home: string +} + +export function defaultAgentConfigHomes(env: NodeJS.ProcessEnv = process.env): AgentConfigHomes { + const home = homedir() + return { + claudeDir: env.CLAUDE_CONFIG_DIR?.trim() || join(home, '.claude'), + codexDir: env.CODEX_HOME?.trim() || join(home, '.codex'), + home + } +} + +/** The folder that holds every item of a kind; null when the kind has no such scope. */ +export function agentConfigRoot( + kind: AgentConfigItemKind, + scope: AgentConfigItemScope, + homes: AgentConfigHomes, + projectPath: string | null +): string | null { + if (scope === 'project') { + if (!projectPath) { + return null + } + switch (kind) { + case 'claude-skill': + return join(projectPath, '.claude', 'skills') + case 'claude-command': + return join(projectPath, '.claude', 'commands') + case 'agents-skill': + return join(projectPath, '.agents', 'skills') + // Codex reads prompts and its older skills folder from home only. + case 'codex-skill': + case 'codex-prompt': + return null + } + } + switch (kind) { + case 'claude-skill': + return join(homes.claudeDir, 'skills') + case 'claude-command': + return join(homes.claudeDir, 'commands') + case 'agents-skill': + return join(homes.home, '.agents', 'skills') + case 'codex-skill': + return join(homes.codexDir, 'skills') + case 'codex-prompt': + return join(homes.codexDir, 'prompts') + } +} + +/** Where one item lives under its root: a folder for skills, `.md` for commands. */ +export function agentConfigItemPath(root: string, kind: AgentConfigItemKind, name: string): string { + return AGENT_CONFIG_FILE_KINDS.has(kind) + ? join(root, ...`${name}.md`.split('/')) + : join(root, name) +} diff --git a/src/main/agent-config-sync/desktop/agent-config-secret-scan.ts b/src/main/agent-config-sync/desktop/agent-config-secret-scan.ts new file mode 100644 index 00000000000..4638368c1d9 --- /dev/null +++ b/src/main/agent-config-sync/desktop/agent-config-secret-scan.ts @@ -0,0 +1,41 @@ +/** + * Skills sometimes sit next to keys a script reads. Those files stay on this computer: names that + * hold credentials by convention, and text with a well-known key or token shape. + */ + +const SECRET_FILE_NAMES = [ + /^\.?env(\..*)?$/i, + /\.(pem|key|p12|pfx|jks|keystore|ppk|asc|gpg|kdbx|der|crt)$/i, + /^id_(rsa|dsa|ecdsa|ed25519)(\.pub)?$/i, + /^(credentials?|secrets?|tokens?|auth|service[-_]?account)([-_.].*)?\.(json|ya?ml|toml|txt|ini|env)$/i, + /^\.?(npmrc|netrc|pypirc|htpasswd|git-credentials)$/i, + /^client_secret.*\.json$/i +] + +const SECRET_CONTENT = [ + /-----BEGIN (?:[A-Z0-9]+ )?PRIVATE KEY-----/, + /\bAKIA[0-9A-Z]{16}\b/, + /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36,}\b/, + /\bgithub_pat_[A-Za-z0-9_]{60,}\b/, + /\bglpat-[A-Za-z0-9_-]{20,}\b/, + /\bsk-ant-[A-Za-z0-9_-]{20,}\b/, + /\bsk-(?:proj-|live_|test_)?[A-Za-z0-9_-]{32,}\b/, + /\bxox[abposr]-[A-Za-z0-9-]{10,}\b/, + /\bAIza[0-9A-Za-z_-]{35}\b/, + /\bnpm_[A-Za-z0-9]{36}\b/, + /\b(?:rk|sk)_live_[A-Za-z0-9]{20,}\b/, + /\bvck_[A-Za-z0-9]{20,}\b/ +] + +export function isSecretFileName(name: string): boolean { + return SECRET_FILE_NAMES.some((pattern) => pattern.test(name)) +} + +/** Binary files are not scanned: the patterns are text shapes. */ +export function hasSecretContent(bytes: Buffer): boolean { + if (bytes.subarray(0, 8000).includes(0)) { + return false + } + const text = bytes.toString('utf8') + return SECRET_CONTENT.some((pattern) => pattern.test(text)) +} diff --git a/src/main/agent-config-sync/desktop/agent-config-sync-plan.ts b/src/main/agent-config-sync/desktop/agent-config-sync-plan.ts new file mode 100644 index 00000000000..9cd665f6660 --- /dev/null +++ b/src/main/agent-config-sync/desktop/agent-config-sync-plan.ts @@ -0,0 +1,190 @@ +import { + AGENT_CONFIG_LIMITS, + agentConfigItemKey, + type AgentConfigItemKind, + type AgentConfigItemPayload, + type AgentConfigItemRef, + type AgentConfigSyncPlanResult, + type AgentConfigSyncPutResult, + type AgentConfigSyncRow +} from '../../../shared/agent-config-sync/agent-config-sync-contract' +import type { AgentConfigDigestEntry } from '../agent-config-digest' +import type { LocalAgentConfigItem } from './local-agent-config-read' + +export type DesiredAgentConfigItem = AgentConfigItemRef & { + key: string + files: AgentConfigDigestEntry[] +} + +export type AgentConfigSyncPlan = { + rows: AgentConfigSyncRow[] + desired: DesiredAgentConfigItem[] +} + +/** The other agent's kind an item converts to; the formats match (SKILL.md folders, Markdown prompts). */ +function counterpartKind(item: LocalAgentConfigItem): AgentConfigItemKind | null { + switch (item.kind) { + case 'claude-skill': + return 'agents-skill' + case 'agents-skill': + case 'codex-skill': + return 'claude-skill' + case 'claude-command': + // Codex prompts are flat: a namespaced command has no Codex name. + return item.name.includes('/') ? null : 'codex-prompt' + case 'codex-prompt': + return 'claude-command' + } +} + +/** Kinds that already give the other agent an item of that name. */ +const NATIVE_FOR: Record = { + 'agents-skill': ['agents-skill', 'codex-skill'], + 'codex-skill': ['agents-skill', 'codex-skill'], + 'claude-skill': ['claude-skill'], + 'claude-command': ['claude-command'], + 'codex-prompt': ['codex-prompt'] +} + +function rowOf(item: LocalAgentConfigItem, key: string, included: boolean): AgentConfigSyncRow { + return { + key, + scope: item.scope, + kind: item.kind, + name: item.name, + bytes: item.bytes, + fileCount: item.fileCount, + withheldFiles: item.withheldFiles, + included, + state: 'pending' + } +} + +/** What to send and how each local item shows, before the host answers. */ +export function planAgentConfigSync(args: { + items: readonly LocalAgentConfigItem[] + excluded: ReadonlySet + shareAcrossAgents: boolean +}): AgentConfigSyncPlan { + const rows: AgentConfigSyncRow[] = [] + const candidates: { row: AgentConfigSyncRow; item: LocalAgentConfigItem }[] = [] + const names = new Set( + args.items.filter((item) => item.scope === 'user').map((item) => `${item.kind}:${item.name}`) + ) + const converted = new Set() + for (const item of args.items) { + const key = agentConfigItemKey(item.scope, item.kind, item.name) + const included = !args.excluded.has(key) + const row = rowOf(item, key, included) + if (item.skipReason) { + rows.push({ ...row, state: 'skipped', skipReason: item.skipReason }) + continue + } + if (!included) { + rows.push({ ...row, state: 'skipped', skipReason: 'turned-off' }) + continue + } + rows.push(row) + candidates.push({ row, item }) + const target = args.shareAcrossAgents && item.scope === 'user' ? counterpartKind(item) : null + if ( + !target || + NATIVE_FOR[target].some((kind) => names.has(`${kind}:${item.name}`)) || + converted.has(`${target}:${item.name}`) + ) { + continue + } + // One copy per name: .agents and the older .codex skills folder can both hold it. + converted.add(`${target}:${item.name}`) + const copy = { ...item, kind: target } + const copyRow: AgentConfigSyncRow = { + ...rowOf(copy, agentConfigItemKey('user', target, item.name), true), + convertedFrom: key + } + rows.push(copyRow) + candidates.push({ row: copyRow, item: copy }) + } + // Natives first, so a copy is what falls past the limit. + candidates.sort((a, b) => Number(!!a.row.convertedFrom) - Number(!!b.row.convertedFrom)) + const desired: DesiredAgentConfigItem[] = [] + let total = 0 + for (const { row, item } of candidates) { + if ( + desired.length >= AGENT_CONFIG_LIMITS.items || + total + item.bytes > AGENT_CONFIG_LIMITS.totalBytes || + !item.digest + ) { + row.state = 'skipped' + row.skipReason = 'over-limit' + continue + } + total += item.bytes + desired.push({ + key: row.key, + scope: item.scope, + kind: item.kind, + name: item.name, + digest: item.digest, + files: item.files + }) + } + return { rows, desired } +} + +/** Put calls that each stay under one item's byte budget (and so under the RPC frame). */ +export function agentConfigPutBatches( + items: readonly DesiredAgentConfigItem[] +): AgentConfigItemPayload[][] { + const batches: AgentConfigItemPayload[][] = [] + let current: AgentConfigItemPayload[] = [] + let bytes = 0 + for (const item of items) { + const size = item.files.reduce((sum, file) => sum + file.bytes.length, 0) + if ( + current.length > 0 && + (bytes + size > AGENT_CONFIG_LIMITS.itemBytes || + current.length >= AGENT_CONFIG_LIMITS.putItems) + ) { + batches.push(current) + current = [] + bytes = 0 + } + current.push({ + scope: item.scope, + kind: item.kind, + name: item.name, + digest: item.digest, + files: item.files.map((file) => ({ + path: file.path, + executable: file.executable, + base64: file.bytes.toString('base64') + })) + }) + bytes += size + } + if (current.length > 0) { + batches.push(current) + } + return batches +} + +const SYNCED_OUTCOMES: ReadonlySet = new Set(['added', 'updated', 'unchanged']) + +/** Rows after the host's plan and puts answered. */ +export function applyAgentConfigSyncResults( + rows: readonly AgentConfigSyncRow[], + plan: AgentConfigSyncPlanResult, + put: AgentConfigSyncPutResult['items'] +): AgentConfigSyncRow[] { + return rows.map((row) => { + if (row.state === 'skipped') { + return row + } + const outcome = put[row.key] ?? plan.items[row.key] + if (!outcome) { + return row + } + const synced = SYNCED_OUTCOMES.has(outcome) + return { ...row, state: synced ? 'synced' : 'skipped', outcome } + }) +} diff --git a/src/main/agent-config-sync/desktop/cloud-agent-config-sync-ipc.ts b/src/main/agent-config-sync/desktop/cloud-agent-config-sync-ipc.ts new file mode 100644 index 00000000000..830c47a73a1 --- /dev/null +++ b/src/main/agent-config-sync/desktop/cloud-agent-config-sync-ipc.ts @@ -0,0 +1,84 @@ +import { BrowserWindow, ipcMain } from 'electron' +import { + CLOUD_AGENT_CONFIG_SYNC_CHANGED_CHANNEL, + CLOUD_AGENT_CONFIG_SYNC_PREFERENCES_CHANNEL, + type CloudAgentConfigSyncPreferences +} from '../../../shared/agent-config-sync/agent-config-sync-contract' +import { createCloudAgentConfigSync, type CloudAgentConfigSync } from './cloud-agent-config-sync' + +let instance: CloudAgentConfigSync | null = null + +function send(channel: string, payload: unknown): void { + for (const window of BrowserWindow.getAllWindows()) { + if (!window.isDestroyed()) { + window.webContents.send(channel, payload) + } + } +} + +function environmentIdOf(value: unknown): string | null { + return typeof value === 'string' && value.length > 0 && value.length <= 256 ? value : null +} + +function preferencesOf(value: unknown): Partial { + if (!value || typeof value !== 'object') { + return {} + } + const raw = value as Record + return { + ...(typeof raw.autoSync === 'boolean' ? { autoSync: raw.autoSync } : {}), + ...(typeof raw.shareAcrossAgents === 'boolean' + ? { shareAcrossAgents: raw.shareAcrossAgents } + : {}) + } +} + +/** Orca Cloud builds only; other builds answer null so the renderer hides the pane. */ +export function installCloudAgentConfigSync(userDataPath: string): CloudAgentConfigSync { + instance ??= createCloudAgentConfigSync({ + userDataPath, + broadcast: (status) => send(CLOUD_AGENT_CONFIG_SYNC_CHANGED_CHANNEL, status), + broadcastPreferences: (preferences) => + send(CLOUD_AGENT_CONFIG_SYNC_PREFERENCES_CHANNEL, preferences) + }) + return instance +} + +const CHANNELS = [ + 'cloudAgentConfigSync:getStatus', + 'cloudAgentConfigSync:syncNow', + 'cloudAgentConfigSync:getPreferences', + 'cloudAgentConfigSync:setPreferences', + 'cloudAgentConfigSync:setItemIncluded' +] as const + +export function registerCloudAgentConfigSyncHandlers(): void { + for (const channel of CHANNELS) { + ipcMain.removeHandler(channel) + } + ipcMain.handle('cloudAgentConfigSync:getStatus', (_event, value: unknown) => { + const environmentId = environmentIdOf(value) + return environmentId && instance ? instance.getStatus(environmentId) : null + }) + ipcMain.handle('cloudAgentConfigSync:syncNow', (_event, value: unknown) => { + const environmentId = environmentIdOf(value) + return environmentId && instance ? instance.sync(environmentId, 'manual') : null + }) + ipcMain.handle('cloudAgentConfigSync:getPreferences', async () => { + if (!instance) { + return null + } + await instance.ready + return instance.getPreferences() + }) + ipcMain.handle('cloudAgentConfigSync:setPreferences', (_event, value: unknown) => + instance ? instance.setPreferences(preferencesOf(value)) : null + ) + ipcMain.handle( + 'cloudAgentConfigSync:setItemIncluded', + (_event, key: unknown, included: unknown) => + instance && typeof key === 'string' && key.length <= 300 && typeof included === 'boolean' + ? instance.setItemIncluded(key, included) + : null + ) +} diff --git a/src/main/agent-config-sync/desktop/cloud-agent-config-sync-support.ts b/src/main/agent-config-sync/desktop/cloud-agent-config-sync-support.ts new file mode 100644 index 00000000000..d8729ef0ff5 --- /dev/null +++ b/src/main/agent-config-sync/desktop/cloud-agent-config-sync-support.ts @@ -0,0 +1,59 @@ +import type { + AgentConfigSyncStatus, + CloudAgentConfigSyncPreferences +} from '../../../shared/agent-config-sync/agent-config-sync-contract' +import { gitExecFileAsync } from '../../git/command-runner/git-exec-file' + +export const MAX_EXCLUDED = 1024 + +// Off until the user turns it on: a cloud workspace can be shared with a team, and skills are +// the user's own prompts. One switch in Settings is the consent. +export const DEFAULT_PREFERENCES: CloudAgentConfigSyncPreferences = { + autoSync: false, + shareAcrossAgents: false, + excluded: [] +} + +export class RuntimeCallError extends Error { + constructor( + message: string, + readonly code: string | undefined + ) { + super(message) + } +} + +export function errorCode(error: unknown): AgentConfigSyncStatus['error'] { + const code = + typeof error === 'object' && error !== null && 'code' in error ? String(error.code) : '' + if (code === 'method_not_found') { + return 'host-outdated' + } + return /unavailable|timeout|unreachable/.test(code) ? 'host-unreachable' : 'failed' +} + +/** Repo-relative files git tracks under the project agent folders. */ +export async function trackedAgentConfigPaths(repoPath: string): Promise> { + const { stdout } = await gitExecFileAsync( + ['ls-files', '-z', '--', '.claude/skills', '.claude/commands', '.agents/skills'], + { cwd: repoPath, timeout: 10_000 } + ) + return new Set(stdout.split('\0').filter(Boolean)) +} + +export function parsePreferences(text: string): CloudAgentConfigSyncPreferences { + const raw: unknown = JSON.parse(text) + if (!raw || typeof raw !== 'object') { + return { ...DEFAULT_PREFERENCES, excluded: [] } + } + return { + autoSync: 'autoSync' in raw && raw.autoSync === true, + shareAcrossAgents: 'shareAcrossAgents' in raw && raw.shareAcrossAgents === true, + excluded: + 'excluded' in raw && Array.isArray(raw.excluded) + ? raw.excluded + .filter((key): key is string => typeof key === 'string' && key.length <= 300) + .slice(0, MAX_EXCLUDED) + : [] + } +} diff --git a/src/main/agent-config-sync/desktop/cloud-agent-config-sync.test.ts b/src/main/agent-config-sync/desktop/cloud-agent-config-sync.test.ts new file mode 100644 index 00000000000..1d52ae730cb --- /dev/null +++ b/src/main/agent-config-sync/desktop/cloud-agent-config-sync.test.ts @@ -0,0 +1,263 @@ +import { execFileSync } from 'node:child_process' +import { + chmodSync, + existsSync, + mkdirSync, + mkdtempSync, + readFileSync, + rmSync, + statSync, + writeFileSync +} from 'node:fs' +import { tmpdir } from 'node:os' +import { dirname, join } from 'node:path' +import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' +import { + AGENT_CONFIG_SYNC_PLAN_METHOD, + AGENT_CONFIG_SYNC_PUT_METHOD, + AgentConfigSyncPlanParams, + AgentConfigSyncPutParams, + type AgentConfigSyncStatus +} from '../../../shared/agent-config-sync/agent-config-sync-contract' +import type { AgentConfigHomes } from '../agent-config-roots' +import { planHostAgentConfigSync, putHostAgentConfig } from '../host/host-agent-config-sync' +import { createCloudAgentConfigSync } from './cloud-agent-config-sync' +import { readLocalAgentConfig } from './local-agent-config-read' + +type FakeRuntime = { + runtimeEnvironmentId: string + recipe: { provider: string } + repoPath: string + status: string +} +const runtimes = vi.hoisted((): { list: FakeRuntime[] } => ({ list: [] })) +vi.mock('../../../shared/ephemeral-vm-runtime-store', () => ({ + listEphemeralVmRuntimes: () => runtimes.list +})) + +let dir: string +let local: AgentConfigHomes +let host: AgentConfigHomes +let hostProject: string +let localRepo: string +let calls: { method: string; params: unknown }[] + +function put(path: string, text: string, mode?: number): void { + mkdirSync(dirname(path), { recursive: true }) + writeFileSync(path, text) + if (mode) { + chmodSync(path, mode) + } +} + +function homesUnder(root: string): AgentConfigHomes { + return { home: root, claudeDir: join(root, '.claude'), codexDir: join(root, '.codex') } +} + +beforeEach(() => { + dir = mkdtempSync(join(tmpdir(), 'cloud-agent-config-')) + local = homesUnder(join(dir, 'mac')) + host = homesUnder(join(dir, 'vm')) + localRepo = join(dir, 'mac-repo') + hostProject = join(dir, 'vm-project') + mkdirSync(localRepo, { recursive: true }) + mkdirSync(hostProject, { recursive: true }) + execFileSync('git', ['init', '-q', hostProject]) + calls = [] + runtimes.list = [ + { + runtimeEnvironmentId: 'env-1', + recipe: { provider: 'orca-cloud' }, + repoPath: localRepo, + // Not running, so turning sync on doesn't start its own sync under each test. + status: 'stopped' + } + ] +}) + +afterEach(() => { + rmSync(dir, { recursive: true, force: true }) +}) + +function create(patch: { outdated?: boolean } = {}) { + const statuses: AgentConfigSyncStatus[] = [] + const hostDeps = { homes: host, projectPath: hostProject, ledgerDir: join(dir, 'vm-userdata') } + const sync = createCloudAgentConfigSync({ + userDataPath: join(dir, 'mac-userdata'), + broadcast: (status) => statuses.push(status), + readLocal: (repoPath) => + readLocalAgentConfig({ homes: local, repoPath, trackedPaths: async () => new Set() }), + // The wire schemas run here as they do in orcad, so the test also checks what crosses. + call: async (_environmentId, method, params) => { + calls.push({ method, params }) + if (patch.outdated) { + throw Object.assign(new Error('nope'), { code: 'method_not_found' }) + } + if (method === AGENT_CONFIG_SYNC_PLAN_METHOD) { + return planHostAgentConfigSync(AgentConfigSyncPlanParams.parse(params), hostDeps) + } + if (method === AGENT_CONFIG_SYNC_PUT_METHOD) { + return putHostAgentConfig(AgentConfigSyncPutParams.parse(params), hostDeps) + } + throw new Error(`unexpected ${method}`) + }, + now: () => 1_000 + }) + mkdirSync(join(dir, 'mac-userdata'), { recursive: true }) + return { sync, statuses } +} + +const outcomes = (status: AgentConfigSyncStatus | null) => + Object.fromEntries((status?.rows ?? []).map((row) => [row.key, row.outcome ?? row.skipReason])) + +describe('cloud agent config sync, desktop to host', () => { + it('stays off on connect until the user turns it on, then copies skills and commands', async () => { + put(join(local.claudeDir, 'skills', 'deploy', 'SKILL.md'), '---\nname: deploy\n---\nShip.') + put(join(local.claudeDir, 'skills', 'deploy', 'run.sh'), '#!/bin/sh\n', 0o755) + put(join(local.claudeDir, 'commands', 'review.md'), 'Review $ARGUMENTS') + const { sync } = create() + expect(await sync.sync('env-1', 'connect')).toBeNull() + expect(calls).toEqual([]) + + sync.setPreferences({ autoSync: true }) + const status = await sync.sync('env-1', 'connect') + expect(status?.error).toBeNull() + expect(outcomes(status)).toEqual({ + 'user:claude-skill:deploy': 'added', + 'user:claude-command:review': 'added' + }) + expect(readFileSync(join(host.claudeDir, 'skills', 'deploy', 'SKILL.md'), 'utf8')).toContain( + 'Ship.' + ) + expect(statSync(join(host.claudeDir, 'skills', 'deploy', 'run.sh')).mode & 0o111).not.toBe(0) + expect(readFileSync(join(host.claudeDir, 'commands', 'review.md'), 'utf8')).toBe( + 'Review $ARGUMENTS' + ) + }) + + it('sends nothing the host already has, updates its own copies and removes what was dropped', async () => { + put(join(local.claudeDir, 'skills', 'a', 'SKILL.md'), 'one') + put(join(local.claudeDir, 'skills', 'b', 'SKILL.md'), 'bee') + const { sync } = create() + sync.setPreferences({ autoSync: true }) + await sync.sync('env-1', 'manual') + + calls = [] + expect(outcomes(await sync.sync('env-1', 'manual'))).toEqual({ + 'user:claude-skill:a': 'unchanged', + 'user:claude-skill:b': 'unchanged' + }) + expect(calls.map((call) => call.method)).toEqual([AGENT_CONFIG_SYNC_PLAN_METHOD]) + + put(join(local.claudeDir, 'skills', 'a', 'SKILL.md'), 'two') + rmSync(join(local.claudeDir, 'skills', 'b'), { recursive: true }) + expect(outcomes(await sync.sync('env-1', 'manual'))).toEqual({ + 'user:claude-skill:a': 'updated' + }) + expect(readFileSync(join(host.claudeDir, 'skills', 'a', 'SKILL.md'), 'utf8')).toBe('two') + expect(existsSync(join(host.claudeDir, 'skills', 'b'))).toBe(false) + }) + + it('never touches items made or edited in the sandbox', async () => { + put(join(local.claudeDir, 'skills', 'mine', 'SKILL.md'), 'from the mac') + put(join(local.claudeDir, 'skills', 'edited', 'SKILL.md'), 'from the mac') + put(join(host.claudeDir, 'skills', 'mine', 'SKILL.md'), 'made in the sandbox') + const { sync } = create() + sync.setPreferences({ autoSync: true }) + expect(outcomes(await sync.sync('env-1', 'manual'))).toEqual({ + 'user:claude-skill:mine': 'kept-host', + 'user:claude-skill:edited': 'added' + }) + put(join(host.claudeDir, 'skills', 'edited', 'SKILL.md'), 'changed in the sandbox') + rmSync(join(local.claudeDir, 'skills', 'edited'), { recursive: true }) + await sync.sync('env-1', 'manual') + expect(readFileSync(join(host.claudeDir, 'skills', 'mine', 'SKILL.md'), 'utf8')).toBe( + 'made in the sandbox' + ) + expect(readFileSync(join(host.claudeDir, 'skills', 'edited', 'SKILL.md'), 'utf8')).toBe( + 'changed in the sandbox' + ) + }) + + it('shares skills and commands across agents only when asked, keeping each agent’s own', async () => { + put(join(local.claudeDir, 'skills', 'deploy', 'SKILL.md'), 'claude deploy') + put(join(local.claudeDir, 'skills', 'both', 'SKILL.md'), 'claude both') + put(join(local.home, '.agents', 'skills', 'both', 'SKILL.md'), 'codex both') + put(join(local.home, '.agents', 'skills', 'lint', 'SKILL.md'), 'codex lint') + put(join(local.claudeDir, 'commands', 'review.md'), 'review') + put(join(local.claudeDir, 'commands', 'ns', 'deep.md'), 'namespaced') + put(join(local.codexDir, 'prompts', 'fix.md'), 'fix') + const { sync } = create() + sync.setPreferences({ autoSync: true }) + await sync.sync('env-1', 'manual') + expect(existsSync(join(host.home, '.agents', 'skills', 'deploy'))).toBe(false) + + sync.setPreferences({ shareAcrossAgents: true }) + const status = await sync.sync('env-1', 'manual') + const copies = status?.rows.filter((row) => row.convertedFrom).map((row) => row.key) + expect(copies?.sort()).toEqual([ + 'user:agents-skill:deploy', + 'user:claude-command:fix', + 'user:claude-skill:lint', + 'user:codex-prompt:review' + ]) + expect(readFileSync(join(host.home, '.agents', 'skills', 'deploy', 'SKILL.md'), 'utf8')).toBe( + 'claude deploy' + ) + expect(readFileSync(join(host.home, '.agents', 'skills', 'both', 'SKILL.md'), 'utf8')).toBe( + 'codex both' + ) + expect(readFileSync(join(host.codexDir, 'prompts', 'review.md'), 'utf8')).toBe('review') + expect(readFileSync(join(host.claudeDir, 'commands', 'fix.md'), 'utf8')).toBe('fix') + expect(existsSync(join(host.codexDir, 'prompts', 'deep.md'))).toBe(false) + + // Turning an original off takes its copy with it. + sync.setItemIncluded('user:claude-skill:deploy', false) + await sync.sync('env-1', 'manual') + expect(existsSync(join(host.claudeDir, 'skills', 'deploy'))).toBe(false) + expect(existsSync(join(host.home, '.agents', 'skills', 'deploy'))).toBe(false) + }) + + it('puts untracked project items in the workspace and keeps them out of its git status', async () => { + put(join(localRepo, '.claude', 'skills', 'proj', 'SKILL.md'), 'project skill') + const { sync } = create() + sync.setPreferences({ autoSync: true }) + expect(outcomes(await sync.sync('env-1', 'manual'))).toEqual({ + 'project:claude-skill:proj': 'added' + }) + expect(readFileSync(join(hostProject, '.claude', 'skills', 'proj', 'SKILL.md'), 'utf8')).toBe( + 'project skill' + ) + const exclude = readFileSync(join(hostProject, '.git', 'info', 'exclude'), 'utf8') + expect(exclude.split('\n')).toContain('/.claude/skills/proj/') + const porcelain = execFileSync('git', ['-C', hostProject, 'status', '--porcelain'], { + encoding: 'utf8' + }) + expect(porcelain).toBe('') + }) + + it('says the sandbox is outdated when its Orca has no skill sync', async () => { + put(join(local.claudeDir, 'skills', 'a', 'SKILL.md'), 'x') + const { sync } = create({ outdated: true }) + const status = await sync.sync('env-1', 'manual') + expect(status?.error).toBe('host-outdated') + expect(status?.rows.map((row) => row.state)).toEqual(['pending']) + }) + + it('syncs running workspaces as soon as sync is turned on', async () => { + put(join(local.claudeDir, 'skills', 'a', 'SKILL.md'), 'x') + runtimes.list[0].status = 'running' + const { sync, statuses } = create() + sync.setPreferences({ autoSync: true }) + await vi.waitFor(() => + expect(statuses.some((status) => status.lastSyncedAt !== null)).toBe(true) + ) + expect(existsSync(join(host.claudeDir, 'skills', 'a', 'SKILL.md'))).toBe(true) + }) + + it('answers null for workspaces that are not Orca Cloud', async () => { + const { sync } = create() + expect(await sync.getStatus('env-other')).toBeNull() + expect(await sync.sync('env-other', 'manual')).toBeNull() + }) +}) diff --git a/src/main/agent-config-sync/desktop/cloud-agent-config-sync.ts b/src/main/agent-config-sync/desktop/cloud-agent-config-sync.ts new file mode 100644 index 00000000000..b2aed817bf5 --- /dev/null +++ b/src/main/agent-config-sync/desktop/cloud-agent-config-sync.ts @@ -0,0 +1,295 @@ +import { readFile } from 'node:fs/promises' +import { join } from 'node:path' +import { + AGENT_CONFIG_SYNC_PLAN_METHOD, + AGENT_CONFIG_SYNC_PUT_METHOD, + AgentConfigSyncPlanResult, + AgentConfigSyncPutResult, + type AgentConfigSyncStatus, + type CloudAgentConfigSyncPreferences +} from '../../../shared/agent-config-sync/agent-config-sync-contract' +import { listEphemeralVmRuntimes } from '../../../shared/ephemeral-vm-runtime-store' +import { writeFileAtomically } from '../../filesystem/atomic-file-publication' +import { callRuntimeEnvironment } from '../../ipc/runtime-environments/runtime-environment-transport-routing' +import { defaultAgentConfigHomes } from '../agent-config-roots' +import { + agentConfigPutBatches, + applyAgentConfigSyncResults, + planAgentConfigSync +} from './agent-config-sync-plan' +import { readLocalAgentConfig, type LocalAgentConfigItem } from './local-agent-config-read' +import { readOrCreateSyncerId } from './syncer-id' +import { + DEFAULT_PREFERENCES, + MAX_EXCLUDED, + RuntimeCallError, + errorCode, + parsePreferences, + trackedAgentConfigPaths +} from './cloud-agent-config-sync-support' + +const PLAN_TIMEOUT_MS = 30_000 +const PUT_TIMEOUT_MS = 60_000 + +export type CloudAgentConfigSyncDeps = { + userDataPath: string + broadcast: (status: AgentConfigSyncStatus) => void + broadcastPreferences?: (preferences: CloudAgentConfigSyncPreferences) => void + readLocal?: (repoPath: string | null) => Promise + call?: ( + environmentId: string, + method: string, + params: unknown, + timeoutMs: number + ) => Promise + now?: () => number +} + +export type CloudAgentConfigSync = { + isCloudEnvironment(environmentId: string): boolean + getStatus(environmentId: string): Promise + sync(environmentId: string, trigger: 'connect' | 'manual'): Promise + /** Settles once saved preferences are read; getPreferences answers defaults until then. */ + ready: Promise + getPreferences(): CloudAgentConfigSyncPreferences + setPreferences(next: Partial): CloudAgentConfigSyncPreferences + setItemIncluded(key: string, included: boolean): CloudAgentConfigSyncPreferences +} + +/** Mirrors this computer's skills and slash commands into each Orca Cloud workspace. */ +export function createCloudAgentConfigSync(deps: CloudAgentConfigSyncDeps): CloudAgentConfigSync { + const preferencesPath = join(deps.userDataPath, 'cloud-agent-config-sync.json') + const statuses = new Map() + const queues = new Map>() + const now = deps.now ?? Date.now + const readLocal = + deps.readLocal ?? + ((repoPath) => + readLocalAgentConfig({ + homes: defaultAgentConfigHomes(), + repoPath, + trackedPaths: trackedAgentConfigPaths + })) + const call = + deps.call ?? + (async (environmentId: string, method: string, params: unknown, timeoutMs: number) => { + const response = await callRuntimeEnvironment( + deps.userDataPath, + environmentId, + method, + params, + timeoutMs + ) + if (response.ok) { + return response.result + } + throw new RuntimeCallError(response.error.message, response.error.code) + }) + + let preferences: CloudAgentConfigSyncPreferences | null = null + const ready = readFile(preferencesPath, 'utf8') + .then(parsePreferences) + .catch(() => null) + .then((loaded) => { + // A change saved while this read ran wins. + preferences ??= loaded ?? { ...DEFAULT_PREFERENCES, excluded: [] } + }) + function getPreferences(): CloudAgentConfigSyncPreferences { + return preferences ?? { ...DEFAULT_PREFERENCES, excluded: [] } + } + + function cloudRuntime(environmentId: string) { + return listEphemeralVmRuntimes(deps.userDataPath).find( + (runtime) => + runtime.runtimeEnvironmentId === environmentId && runtime.recipe?.provider === 'orca-cloud' + ) + } + + async function plan(environmentId: string) { + const local = await readLocal(cloudRuntime(environmentId)?.repoPath ?? null) + const prefs = getPreferences() + return planAgentConfigSync({ + items: local, + excluded: new Set(prefs.excluded), + shareAcrossAgents: prefs.shareAcrossAgents + }) + } + + function publish(status: AgentConfigSyncStatus): AgentConfigSyncStatus { + statuses.set(status.environmentId, status) + deps.broadcast(status) + return status + } + + async function run(environmentId: string): Promise { + const previous = statuses.get(environmentId) + const planned = await plan(environmentId).catch(() => null) + if (!planned) { + return publish({ + environmentId, + running: false, + lastSyncedAt: previous?.lastSyncedAt ?? null, + error: 'failed', + rows: previous?.rows ?? [] + }) + } + publish({ + environmentId, + running: true, + lastSyncedAt: previous?.lastSyncedAt ?? null, + error: previous?.error ?? null, + rows: previous?.rows.length ? previous.rows : planned.rows + }) + const syncer = await readOrCreateSyncerId(deps.userDataPath) + try { + const hostPlan = AgentConfigSyncPlanResult.parse( + await call( + environmentId, + AGENT_CONFIG_SYNC_PLAN_METHOD, + { + syncer, + items: planned.desired.map(({ scope, kind, name, digest }) => ({ + scope, + kind, + name, + digest + })) + }, + PLAN_TIMEOUT_MS + ) + ) + const needed = planned.desired.filter((item) => hostPlan.items[item.key] === 'needed') + const put: AgentConfigSyncPutResult['items'] = {} + for (const batch of agentConfigPutBatches(needed)) { + const answer = AgentConfigSyncPutResult.parse( + await call( + environmentId, + AGENT_CONFIG_SYNC_PUT_METHOD, + { syncer, items: batch }, + PUT_TIMEOUT_MS + ) + ) + Object.assign(put, answer.items) + } + const rows = applyAgentConfigSyncResults(planned.rows, hostPlan, put) + const synced = rows.filter((row) => row.state === 'synced').length + console.info( + `[cloud-agent-config-sync] ${environmentId}: ${synced} synced, ${needed.length} sent, ${hostPlan.removed} removed, ${rows.length - synced} not synced` + ) + return publish({ environmentId, running: false, lastSyncedAt: now(), error: null, rows }) + } catch (error) { + const code = errorCode(error) + console.warn(`[cloud-agent-config-sync] ${environmentId}: sync failed (${code})`) + return publish({ + environmentId, + running: false, + lastSyncedAt: previous?.lastSyncedAt ?? null, + error: code, + rows: planned.rows + }) + } + } + + function enqueue(environmentId: string): Promise { + // One sync per workspace at a time; a click during an auto-sync runs after it. + const next = (queues.get(environmentId) ?? Promise.resolve()) + .catch(() => {}) + .then(() => run(environmentId)) + queues.set(environmentId, next) + void next.finally(() => { + if (queues.get(environmentId) === next) { + queues.delete(environmentId) + } + }) + return next + } + + /** After a settings change, bring every workspace that already synced in line with it. */ + function resyncSynced(): void { + for (const status of statuses.values()) { + if (status.lastSyncedAt !== null && cloudRuntime(status.environmentId)) { + void enqueue(status.environmentId).catch(() => {}) + } + } + } + + function setPreferences( + next: Partial + ): CloudAgentConfigSyncPreferences { + const current = getPreferences() + const merged: CloudAgentConfigSyncPreferences = { + autoSync: next.autoSync ?? current.autoSync, + shareAcrossAgents: next.shareAcrossAgents ?? current.shareAcrossAgents, + excluded: [...new Set(next.excluded ?? current.excluded)].sort().slice(0, MAX_EXCLUDED) + } + writeFileAtomically(preferencesPath, `${JSON.stringify(merged, null, 2)}\n`) + preferences = merged + deps.broadcastPreferences?.(merged) + return merged + } + + return { + ready, + isCloudEnvironment: (environmentId) => cloudRuntime(environmentId) !== undefined, + async getStatus(environmentId) { + await ready + if (!cloudRuntime(environmentId)) { + return null + } + const known = statuses.get(environmentId) + if (known) { + return known + } + // Before any sync: what would go, read from this computer only. + const planned = await plan(environmentId).catch(() => null) + return { + environmentId, + running: false, + lastSyncedAt: null, + error: planned ? null : 'failed', + rows: planned?.rows ?? [] + } + }, + async sync(environmentId, trigger) { + await ready + if (!cloudRuntime(environmentId)) { + return null + } + if (trigger === 'connect' && !getPreferences().autoSync) { + return statuses.get(environmentId) ?? null + } + return enqueue(environmentId) + }, + getPreferences, + setPreferences(next) { + const before = getPreferences() + const merged = setPreferences(next) + // Turning sync on reaches the running workspaces now, not at their next wake. + if (merged.autoSync && !before.autoSync) { + for (const runtime of listEphemeralVmRuntimes(deps.userDataPath)) { + if ( + runtime.recipe?.provider === 'orca-cloud' && + runtime.status === 'running' && + runtime.runtimeEnvironmentId + ) { + void enqueue(runtime.runtimeEnvironmentId).catch(() => {}) + } + } + } else if (merged.shareAcrossAgents !== before.shareAcrossAgents) { + resyncSynced() + } + return merged + }, + setItemIncluded(key, included) { + const excluded = new Set(getPreferences().excluded) + if (included) { + excluded.delete(key) + } else { + excluded.add(key) + } + const merged = setPreferences({ excluded: [...excluded] }) + resyncSynced() + return merged + } + } +} diff --git a/src/main/agent-config-sync/desktop/local-agent-config-read.test.ts b/src/main/agent-config-sync/desktop/local-agent-config-read.test.ts new file mode 100644 index 00000000000..445995e8815 --- /dev/null +++ b/src/main/agent-config-sync/desktop/local-agent-config-read.test.ts @@ -0,0 +1,137 @@ +import { chmodSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { dirname, join } from 'node:path' +import { afterEach, beforeEach, describe, expect, it } from 'vitest' +import type { AgentConfigHomes } from '../agent-config-roots' +import { readLocalAgentConfig } from './local-agent-config-read' + +let dir: string +let homes: AgentConfigHomes + +function put(path: string, text: string | Buffer, mode?: number): void { + mkdirSync(dirname(path), { recursive: true }) + writeFileSync(path, text) + if (mode) { + chmodSync(path, mode) + } +} + +beforeEach(() => { + dir = mkdtempSync(join(tmpdir(), 'agent-config-read-')) + homes = { + home: join(dir, 'home'), + claudeDir: join(dir, 'home', '.claude'), + codexDir: join(dir, 'home', '.codex') + } +}) + +afterEach(() => { + rmSync(dir, { recursive: true, force: true }) +}) + +const read = (repoPath: string | null = null, tracked: string[] | null = []) => + readLocalAgentConfig({ + homes, + repoPath, + trackedPaths: async () => (tracked ? new Set(tracked) : null) + }) + +describe('readLocalAgentConfig', () => { + it('reads skills with their files and keeps likely secrets on this computer', async () => { + const skill = join(homes.claudeDir, 'skills', 'deploy') + put(join(skill, 'SKILL.md'), '---\nname: deploy\n---\nShip it.') + put(join(skill, 'scripts', 'run.sh'), '#!/bin/sh\necho hi\n', 0o755) + put(join(skill, 'service-account.json'), '{}') + put(join(skill, 'notes.txt'), 'token: ghp_0123456789abcdefghijABCDEFGHIJ0123456789') + put(join(skill, '.env'), 'X=1') + put(join(skill, 'node_modules', 'x', 'index.js'), 'x') + // Not a skill: no SKILL.md. + put(join(homes.claudeDir, 'skills', 'synced', 'blob.bin'), 'x') + // A link out of the skill folder is not followed. + put(join(dir, 'outside.txt'), 'outside') + symlinkSync(join(dir, 'outside.txt'), join(skill, 'link.txt')) + + const items = await read() + expect(items).toHaveLength(1) + const [item] = items + expect(item).toMatchObject({ + scope: 'user', + kind: 'claude-skill', + name: 'deploy', + withheldFiles: 2 + }) + expect(item.skipReason).toBeUndefined() + expect(item.files.map((file) => [file.path, file.executable])).toEqual([ + ['SKILL.md', false], + ['scripts/run.sh', true] + ]) + expect(item.digest).toMatch(/^[a-f0-9]{64}$/) + }) + + it('skips a skill whose SKILL.md holds a key, and one that is too large', async () => { + put( + join(homes.claudeDir, 'skills', 'leaky', 'SKILL.md'), + 'Use sk-ant-api03-abcdefghijklmnopqrstuvwxyz0123456789' + ) + put(join(homes.claudeDir, 'skills', 'huge', 'SKILL.md'), 'x') + put(join(homes.claudeDir, 'skills', 'huge', 'data.bin'), Buffer.alloc(300 * 1024)) + const items = await read() + expect(Object.fromEntries(items.map((item) => [item.name, item.skipReason]))).toEqual({ + leaky: 'secret', + huge: 'too-large' + }) + expect(items.every((item) => item.files.length === 0)).toBe(true) + }) + + it('reads namespaced Claude commands, flat Codex prompts, and both Codex skill folders', async () => { + put(join(homes.claudeDir, 'commands', 'review.md'), 'Review $ARGUMENTS') + put(join(homes.claudeDir, 'commands', 'frontend', 'component.md'), 'Make a component') + put(join(homes.claudeDir, 'commands', 'README.txt'), 'not a command') + put(join(homes.codexDir, 'prompts', 'fix.md'), 'Fix it') + put(join(homes.codexDir, 'prompts', 'nested', 'ignored.md'), 'Codex prompts are flat') + put(join(homes.home, '.agents', 'skills', 'lint', 'SKILL.md'), 'Lint') + put(join(homes.codexDir, 'skills', '.system', 'builtin', 'SKILL.md'), 'Codex own') + put(join(homes.codexDir, 'skills', 'legacy', 'SKILL.md'), 'Old home') + const items = await read() + expect(items.map((item) => `${item.kind}:${item.name}`).sort()).toEqual([ + 'agents-skill:lint', + 'claude-command:frontend/component', + 'claude-command:review', + 'codex-prompt:fix', + 'codex-skill:legacy' + ]) + const review = items.find((item) => item.name === 'review') + expect(review?.files).toEqual([ + { path: '.', executable: false, bytes: Buffer.from('Review $ARGUMENTS') } + ]) + }) + + it('sends project items git does not track, and marks committed ones as already in the repo', async () => { + const repo = join(dir, 'repo') + put(join(repo, '.claude', 'skills', 'committed', 'SKILL.md'), 'in git') + put(join(repo, '.claude', 'skills', 'local-only', 'SKILL.md'), 'not in git') + put(join(repo, '.claude', 'commands', 'ship.md'), 'in git') + put(join(repo, '.claude', 'commands', 'mine.md'), 'not in git') + const items = await read(repo, [ + '.claude/skills/committed/SKILL.md', + '.claude/commands/ship.md' + ]) + expect( + Object.fromEntries( + items.map((item) => [`${item.scope}:${item.name}`, item.skipReason ?? 'send']) + ) + ).toEqual({ + 'project:committed': 'in-repo', + 'project:local-only': 'send', + 'project:ship': 'in-repo', + 'project:mine': 'send' + }) + }) + + it('treats project items as committed when git cannot answer', async () => { + const repo = join(dir, 'repo') + put(join(repo, '.claude', 'skills', 'a', 'SKILL.md'), 'x') + const items = await read(repo, null) + expect(items.map((item) => item.skipReason)).toEqual(['in-repo']) + }) +}) diff --git a/src/main/agent-config-sync/desktop/local-agent-config-read.ts b/src/main/agent-config-sync/desktop/local-agent-config-read.ts new file mode 100644 index 00000000000..a40626d3993 --- /dev/null +++ b/src/main/agent-config-sync/desktop/local-agent-config-read.ts @@ -0,0 +1,314 @@ +import { lstat, readFile, readdir, realpath, stat } from 'node:fs/promises' +import { join, relative, sep } from 'node:path' +import { + AGENT_CONFIG_COMMAND_NAME, + AGENT_CONFIG_FILE_PATH, + AGENT_CONFIG_LIMITS, + AGENT_CONFIG_PROJECT_KINDS, + AGENT_CONFIG_SELF_PATH, + AGENT_CONFIG_SKILL_NAME, + AgentConfigItemKind, + isSkillKind, + type AgentConfigItemScope, + type AgentConfigSkipReason +} from '../../../shared/agent-config-sync/agent-config-sync-contract' +import { agentConfigDigest, type AgentConfigDigestEntry } from '../agent-config-digest' +import { agentConfigRoot, type AgentConfigHomes } from '../agent-config-roots' +import { hasSecretContent, isSecretFileName } from './agent-config-secret-scan' + +export type LocalAgentConfigItem = { + scope: AgentConfigItemScope + kind: AgentConfigItemKind + name: string + /** Empty when skipped. */ + files: AgentConfigDigestEntry[] + fileCount: number + bytes: number + withheldFiles: number + digest: string | null + skipReason?: Extract +} + +export type LocalAgentConfigReadDeps = { + homes: AgentConfigHomes + /** The workspace's checkout on this computer, for project items. */ + repoPath: string | null + /** Repo-relative paths git tracks under the project agent folders; null when git can't say. */ + trackedPaths: (repoPath: string) => Promise | null> +} + +/** Folders a skill never needs in the sandbox. */ +const SKIPPED_DIRS = new Set(['node_modules', '__pycache__', 'venv']) +const MAX_DEPTH = 8 +const SKILL_FILE = 'SKILL.md' + +type Walked = + | { ok: true; files: AgentConfigDigestEntry[]; withheld: number; bytes: number } + | { ok: false; reason: 'too-large' | 'secret' | 'invalid' } + +async function isExecutable(path: string): Promise { + try { + return ((await stat(path)).mode & 0o111) !== 0 + } catch { + return false + } +} + +/** One file's verdict: kept, kept back as a likely secret, or too big for any skill. */ +async function readItemFile( + path: string, + name: string +): Promise<'too-large' | 'withheld' | { bytes: Buffer; executable: boolean }> { + const info = await stat(path) + if (info.size > AGENT_CONFIG_LIMITS.fileBytes) { + return 'too-large' + } + if (isSecretFileName(name)) { + return 'withheld' + } + const bytes = await readFile(path) + if (hasSecretContent(bytes)) { + return 'withheld' + } + return { bytes, executable: await isExecutable(path) } +} + +/** Every regular file in a skill folder; symlinks only when they stay inside it. */ +async function walkSkill(dir: string): Promise { + const root = await realpath(dir) + const files: AgentConfigDigestEntry[] = [] + let withheld = 0 + let bytes = 0 + const visit = async (current: string, depth: number): Promise => { + const entries = await readdir(current, { withFileTypes: true }) + entries.sort((a, b) => (a.name < b.name ? -1 : 1)) + for (const entry of entries) { + if (entry.name.startsWith('.') || SKIPPED_DIRS.has(entry.name)) { + continue + } + const path = join(current, entry.name) + let resolved = path + if (entry.isSymbolicLink()) { + try { + resolved = await realpath(path) + } catch { + continue + } + if (resolved !== root && !resolved.startsWith(root + sep)) { + continue + } + } + const info = await stat(resolved).catch(() => null) + if (!info) { + continue + } + const rel = relative(dir, path).split(sep).join('/') + if (info.isDirectory()) { + if (depth >= MAX_DEPTH) { + continue + } + const nested = await visit(path, depth + 1) + if (nested) { + return nested + } + continue + } + if (!info.isFile()) { + continue + } + if (!AGENT_CONFIG_FILE_PATH.test(rel)) { + return { ok: false, reason: 'invalid' } + } + const read = await readItemFile(resolved, entry.name) + if (read === 'too-large') { + return { ok: false, reason: 'too-large' } + } + if (read === 'withheld') { + if (rel === SKILL_FILE) { + return { ok: false, reason: 'secret' } + } + withheld += 1 + continue + } + bytes += read.bytes.length + files.push({ path: rel, executable: read.executable, bytes: read.bytes }) + if ( + files.length > AGENT_CONFIG_LIMITS.filesPerItem || + bytes > AGENT_CONFIG_LIMITS.itemBytes + ) { + return { ok: false, reason: 'too-large' } + } + } + return null + } + const failed = await visit(dir, 0) + return failed ?? { ok: true, files, withheld, bytes } +} + +async function isDirectory(path: string): Promise { + return (await stat(path).catch(() => null))?.isDirectory() === true +} + +async function isFile(path: string): Promise { + return (await stat(path).catch(() => null))?.isFile() === true +} + +async function readSkills( + root: string, + kind: AgentConfigItemKind, + scope: AgentConfigItemScope +): Promise { + const entries = await readdir(root, { withFileTypes: true }).catch(() => []) + const items: LocalAgentConfigItem[] = [] + for (const entry of entries) { + const dir = join(root, entry.name) + // Hidden folders hold tool state (Codex's .system skills, trash), not the user's skills. + if (entry.name.startsWith('.') || !(await isDirectory(dir))) { + continue + } + if (!(await isFile(join(dir, SKILL_FILE)))) { + continue + } + const base = { scope, kind, name: entry.name, withheldFiles: 0 } + if (!AGENT_CONFIG_SKILL_NAME.test(entry.name)) { + items.push({ + ...base, + files: [], + fileCount: 0, + bytes: 0, + digest: null, + skipReason: 'invalid' + }) + continue + } + const walked = await walkSkill(dir).catch((): Walked => ({ ok: false, reason: 'invalid' })) + if (!walked.ok) { + items.push({ + ...base, + files: [], + fileCount: 0, + bytes: 0, + digest: null, + skipReason: walked.reason + }) + continue + } + items.push({ + ...base, + files: walked.files, + fileCount: walked.files.length, + bytes: walked.bytes, + withheldFiles: walked.withheld, + digest: agentConfigDigest(walked.files) + }) + } + return items +} + +/** Markdown commands, namespaced by folder (Claude) or flat (Codex prompts). */ +async function readCommands( + root: string, + kind: AgentConfigItemKind, + scope: AgentConfigItemScope +): Promise { + const maxDepth = kind === 'codex-prompt' ? 0 : 2 + const items: LocalAgentConfigItem[] = [] + const visit = async (dir: string, depth: number): Promise => { + const entries = await readdir(dir, { withFileTypes: true }).catch(() => []) + for (const entry of entries) { + if (entry.name.startsWith('.')) { + continue + } + const path = join(dir, entry.name) + const info = await stat(path).catch(() => null) + if (info?.isDirectory()) { + if (depth < maxDepth) { + await visit(path, depth + 1) + } + continue + } + if (!info?.isFile() || !entry.name.endsWith('.md')) { + continue + } + const name = relative(root, path).split(sep).join('/').slice(0, -'.md'.length) + const base = { scope, kind, name, withheldFiles: 0, fileCount: 1 } + const skipped = ( + skipReason: NonNullable + ): LocalAgentConfigItem => ({ + ...base, + files: [], + bytes: info.size, + digest: null, + skipReason + }) + if (!AGENT_CONFIG_COMMAND_NAME.test(name)) { + items.push(skipped('invalid')) + continue + } + const read = await readItemFile(path, entry.name).catch(() => 'invalid' as const) + if (read === 'too-large' || read === 'invalid') { + items.push(skipped(read)) + continue + } + if (read === 'withheld') { + items.push(skipped('secret')) + continue + } + const files = [ + { path: AGENT_CONFIG_SELF_PATH, executable: false, bytes: read.bytes } // commands are never run + ] + items.push({ ...base, files, bytes: read.bytes.length, digest: agentConfigDigest(files) }) + } + } + await visit(root, 0) + return items +} + +/** Repo-relative path of an item, as `git ls-files` prints it. */ +function repoRelative(repoPath: string, root: string, kind: AgentConfigItemKind, name: string) { + const rel = relative(repoPath, root).split(sep).join('/') + return isSkillKind(kind) ? `${rel}/${name}/` : `${rel}/${name}.md` +} + +/** This computer's Claude Code and Codex skills and commands, user scope and the workspace's project. */ +export async function readLocalAgentConfig( + deps: LocalAgentConfigReadDeps +): Promise { + const items: LocalAgentConfigItem[] = [] + for (const kind of AgentConfigItemKind.options) { + const root = agentConfigRoot(kind, 'user', deps.homes, null) + if (root) { + items.push(...(await (isSkillKind(kind) ? readSkills : readCommands)(root, kind, 'user'))) + } + } + const repoPath = deps.repoPath + if (repoPath) { + const tracked = await deps.trackedPaths(repoPath).catch(() => null) + for (const kind of AgentConfigItemKind.options) { + const root = AGENT_CONFIG_PROJECT_KINDS.has(kind) + ? agentConfigRoot(kind, 'project', deps.homes, repoPath) + : null + // A project folder that is a link elsewhere is not the repo's; leave it alone. + if (!root || (await lstat(root).catch(() => null))?.isSymbolicLink()) { + continue + } + for (const item of await (isSkillKind(kind) ? readSkills : readCommands)( + root, + kind, + 'project' + )) { + const path = repoRelative(repoPath, root, kind, item.name) + // Committed items reach the sandbox with the clone; unknown means assume committed. + const inRepo = + tracked === null || + [...tracked].some((file) => (isSkillKind(kind) ? file.startsWith(path) : file === path)) + items.push( + inRepo && !item.skipReason + ? { ...item, files: [], digest: null, skipReason: 'in-repo' } + : item + ) + } + } + } + return items +} diff --git a/src/main/agent-config-sync/desktop/syncer-id.ts b/src/main/agent-config-sync/desktop/syncer-id.ts new file mode 100644 index 00000000000..11d62650060 --- /dev/null +++ b/src/main/agent-config-sync/desktop/syncer-id.ts @@ -0,0 +1,37 @@ +import { randomBytes } from 'node:crypto' +import { readFile } from 'node:fs/promises' +import { join } from 'node:path' +import { writeFileAtomically } from '../../filesystem/atomic-file-publication' + +// One read per profile; concurrent first syncs share it, so they can't mint two ids. +const cache = new Map>() + +async function load(userDataPath: string): Promise { + const path = join(userDataPath, 'mcp-sync-syncer-id') + try { + const stored = (await readFile(path, 'utf8')).trim() + if (/^[a-f0-9]{16}$/.test(stored)) { + return stored + } + } catch { + // First sync from this computer. + } + const id = randomBytes(8).toString('hex') + try { + writeFileAtomically(path, `${id}\n`) + } catch { + // Unwritable profile: this run still syncs as itself; the next launch gets a new id. + } + return id +} + +/** This computer's stable sync identity (random, not a device fingerprint). The host keeps one + * ledger per syncer, so two computers syncing one sandbox never remove each other's items. */ +export function readOrCreateSyncerId(userDataPath: string): Promise { + let id = cache.get(userDataPath) + if (!id) { + id = load(userDataPath) + cache.set(userDataPath, id) + } + return id +} diff --git a/src/main/agent-config-sync/host/host-agent-config-ledger.ts b/src/main/agent-config-sync/host/host-agent-config-ledger.ts new file mode 100644 index 00000000000..9242f4c3a46 --- /dev/null +++ b/src/main/agent-config-sync/host/host-agent-config-ledger.ts @@ -0,0 +1,74 @@ +import { runProcess } from '@orca/process-host' +import { appendFile, mkdir, readFile } from 'node:fs/promises' +import { dirname, join } from 'node:path' +import { writeFileAtomically } from '../../filesystem/atomic-file-publication' + +/** What this host last wrote for one syncing computer: item key -> digest. Never contents. */ +export type Ledger = { version: 1; items: Record } + +export function ledgerPath(ledgerDir: string, syncer: string): string { + return join(ledgerDir, `agent-config-sync-ledger-${syncer}.json`) +} + +export async function readLedger(path: string): Promise { + try { + const parsed: unknown = JSON.parse(await readFile(path, 'utf8')) + const items = + parsed && typeof parsed === 'object' && 'items' in parsed ? parsed.items : undefined + const clean: Record = {} + if (items && typeof items === 'object') { + for (const [key, value] of Object.entries(items)) { + if (typeof value === 'string' && /^[a-f0-9]{64}$/.test(value)) { + clean[key] = value + } + } + } + return { version: 1, items: clean } + } catch { + return { version: 1, items: {} } + } +} + +export async function writeLedger(path: string, ledger: Ledger): Promise { + await mkdir(dirname(path), { recursive: true }) + writeFileAtomically(path, `${JSON.stringify(ledger, null, 2)}\n`, { mode: 0o600 }) +} + +/** Keeps a synced project item out of the sandbox's git status (local exclude, never committed). */ +export async function excludeFromGit( + projectPath: string, + dest: string, + isDir: boolean +): Promise { + try { + const { code, stdout } = await runProcess({ + program: 'git', + args: [ + '-C', + projectPath, + 'rev-parse', + '--path-format=absolute', + '--git-path', + 'info/exclude' + ], + timeoutMs: 5_000 + }) + if (code !== 0) { + return + } + const excludePath = stdout.trim() + if (!excludePath) { + return + } + const rel = dest.slice(projectPath.length).split('\\').join('/') + const line = `${rel.startsWith('/') ? rel : `/${rel}`}${isDir ? '/' : ''}` + const current = await readFile(excludePath, 'utf8').catch(() => '') + if (current.split('\n').includes(line)) { + return + } + await mkdir(dirname(excludePath), { recursive: true }) + await appendFile(excludePath, `${current && !current.endsWith('\n') ? '\n' : ''}${line}\n`) + } catch { + // Not a git checkout here; the item still works, it just shows as untracked. + } +} diff --git a/src/main/agent-config-sync/host/host-agent-config-sync.test.ts b/src/main/agent-config-sync/host/host-agent-config-sync.test.ts new file mode 100644 index 00000000000..65f9949217e --- /dev/null +++ b/src/main/agent-config-sync/host/host-agent-config-sync.test.ts @@ -0,0 +1,143 @@ +import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs' +import { tmpdir } from 'node:os' +import { join } from 'node:path' +import { afterEach, beforeEach, describe, expect, it } from 'vitest' +import { + AgentConfigSyncPlanParams, + AgentConfigSyncPutParams +} from '../../../shared/agent-config-sync/agent-config-sync-contract' +import { agentConfigDigest } from '../agent-config-digest' +import { + planHostAgentConfigSync, + putHostAgentConfig, + type HostAgentConfigSyncDeps +} from './host-agent-config-sync' + +let dir: string +let deps: HostAgentConfigSyncDeps + +beforeEach(() => { + dir = mkdtempSync(join(tmpdir(), 'host-agent-config-')) + deps = { + homes: { home: dir, claudeDir: join(dir, '.claude'), codexDir: join(dir, '.codex') }, + projectPath: null, + ledgerDir: join(dir, 'userData') + } +}) + +afterEach(() => { + rmSync(dir, { recursive: true, force: true }) +}) + +const skillFiles = [{ path: 'SKILL.md', executable: false, bytes: Buffer.from('hello') }] +const digest = agentConfigDigest(skillFiles) +const payload = (patch: Record = {}) => ({ + scope: 'user' as const, + kind: 'claude-skill' as const, + name: 'hello', + digest, + files: [{ path: 'SKILL.md', executable: false, base64: Buffer.from('hello').toString('base64') }], + ...patch +}) + +describe('host agent config sync', () => { + it('rejects names and paths that could leave the agent folders', () => { + for (const name of ['../x', '.hidden', 'a/b', '']) { + expect( + AgentConfigSyncPlanParams.safeParse({ + syncer: 's', + items: [{ scope: 'user', kind: 'claude-skill', name, digest }] + }).success + ).toBe(false) + } + for (const path of ['../SKILL.md', '/etc/passwd', 'a/../../b', '.git/config']) { + expect( + AgentConfigSyncPutParams.safeParse({ + syncer: 's', + items: [payload({ files: [{ path, executable: false, base64: '' }] })] + }).success + ).toBe(false) + } + // Codex prompts and old Codex skills have no project scope. + expect( + AgentConfigSyncPlanParams.safeParse({ + syncer: 's', + items: [{ scope: 'project', kind: 'codex-prompt', name: 'x', digest }] + }).success + ).toBe(false) + }) + + it('refuses a payload that does not match its digest or lacks SKILL.md', async () => { + const result = await putHostAgentConfig( + { + syncer: 's', + items: [ + payload({ digest: '0'.repeat(64) }), + payload({ + name: 'nomain', + digest: agentConfigDigest([ + { path: 'other.md', executable: false, bytes: Buffer.from('x') } + ]), + files: [ + { path: 'other.md', executable: false, base64: Buffer.from('x').toString('base64') } + ] + }) + ] + }, + deps + ) + expect(result.items).toEqual({ + 'user:claude-skill:hello': 'invalid', + 'user:claude-skill:nomain': 'invalid' + }) + expect(existsSync(join(dir, '.claude', 'skills'))).toBe(false) + }) + + it('leaves a symlinked skill alone and keeps project items out without a workspace', async () => { + mkdirSync(join(dir, '.claude', 'skills'), { recursive: true }) + mkdirSync(join(dir, 'elsewhere')) + symlinkSync(join(dir, 'elsewhere'), join(dir, '.claude', 'skills', 'hello')) + const plan = await planHostAgentConfigSync( + { + syncer: 's', + items: [ + { scope: 'user', kind: 'claude-skill', name: 'hello', digest }, + { scope: 'project', kind: 'claude-skill', name: 'proj', digest } + ] + }, + deps + ) + expect(plan.items).toEqual({ + 'user:claude-skill:hello': 'kept-host', + 'project:claude-skill:proj': 'no-project' + }) + }) + + it('ignores ledger entries that do not name a valid item', async () => { + mkdirSync(deps.ledgerDir, { recursive: true }) + writeFileSync( + join(deps.ledgerDir, 'agent-config-sync-ledger-s.json'), + JSON.stringify({ version: 1, items: { 'user:claude-skill:../../victim': digest } }) + ) + mkdirSync(join(dir, 'victim')) + writeFileSync(join(dir, 'victim', 'SKILL.md'), 'hello') + const plan = await planHostAgentConfigSync({ syncer: 's', items: [] }, deps) + expect(plan.removed).toBe(0) + expect(existsSync(join(dir, 'victim', 'SKILL.md'))).toBe(true) + }) + + it('keeps each computer’s items separate', async () => { + await planHostAgentConfigSync( + { syncer: 'mac-a', items: [{ scope: 'user', kind: 'claude-skill', name: 'hello', digest }] }, + deps + ) + await putHostAgentConfig({ syncer: 'mac-a', items: [payload()] }, deps) + // Another computer that never sent it doesn't remove it. + const other = await planHostAgentConfigSync({ syncer: 'mac-b', items: [] }, deps) + expect(other.removed).toBe(0) + expect(existsSync(join(dir, '.claude', 'skills', 'hello', 'SKILL.md'))).toBe(true) + const own = await planHostAgentConfigSync({ syncer: 'mac-a', items: [] }, deps) + expect(own.removed).toBe(1) + expect(existsSync(join(dir, '.claude', 'skills', 'hello'))).toBe(false) + }) +}) diff --git a/src/main/agent-config-sync/host/host-agent-config-sync.ts b/src/main/agent-config-sync/host/host-agent-config-sync.ts new file mode 100644 index 00000000000..81a2c169543 --- /dev/null +++ b/src/main/agent-config-sync/host/host-agent-config-sync.ts @@ -0,0 +1,273 @@ +import { randomBytes } from 'node:crypto' +import { lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises' +import { dirname, isAbsolute, join, resolve } from 'node:path' +import { + AGENT_CONFIG_FILE_KINDS, + AGENT_CONFIG_LIMITS, + AGENT_CONFIG_SELF_PATH, + AgentConfigItemKind, + AgentConfigItemScope, + AgentConfigSyncPlanParams, + agentConfigItemKey, + isSkillKind, + type AgentConfigItemPayload, + type AgentConfigPlanOutcome, + type AgentConfigPutOutcome, + type AgentConfigSyncPlanResult, + type AgentConfigSyncPutParams, + type AgentConfigSyncPutResult +} from '../../../shared/agent-config-sync/agent-config-sync-contract' +import { writeFileAtomically } from '../../filesystem/atomic-file-publication' +import { excludeFromGit, ledgerPath, readLedger, writeLedger } from './host-agent-config-ledger' +import { agentConfigDigest, type AgentConfigDigestEntry } from '../agent-config-digest' +import { agentConfigItemPath, agentConfigRoot, type AgentConfigHomes } from '../agent-config-roots' + +export type HostAgentConfigSyncDeps = { + homes: AgentConfigHomes + /** The host workspace's checkout (ORCA_WORKSPACE_PATH); project items go there. */ + projectPath: string | null + /** Folder for this host's per-computer ledgers. */ + ledgerDir: string +} + +type ItemId = { scope: AgentConfigItemScope; kind: AgentConfigItemKind; name: string } + +function parseKey(key: string): ItemId | null { + const [scope, kind, ...rest] = key.split(':') + const parsedScope = AgentConfigItemScope.safeParse(scope) + const parsedKind = AgentConfigItemKind.safeParse(kind) + const name = rest.join(':') + if (!parsedScope.success || !parsedKind.success || !name) { + return null + } + // Same checks as a fresh request, so a tampered ledger can't name a path outside the roots. + const checked = AgentConfigSyncPlanParams.safeParse({ + syncer: 'ledger', + items: [{ scope, kind, name, digest: '0'.repeat(64) }] + }) + return checked.success ? { scope: parsedScope.data, kind: parsedKind.data, name } : null +} + +function destinationOf(item: ItemId, deps: HostAgentConfigSyncDeps): string | null { + const root = agentConfigRoot(item.kind, item.scope, deps.homes, deps.projectPath) + return root ? agentConfigItemPath(root, item.kind, item.name) : null +} + +/** Digest of what is on disk now: null when absent, 'foreign' for anything not a plain copy. */ +async function digestOnDisk(path: string, kind: AgentConfigItemKind): Promise { + const info = await lstat(path).catch(() => null) + if (!info) { + return null + } + if (info.isSymbolicLink()) { + return 'foreign' + } + if (AGENT_CONFIG_FILE_KINDS.has(kind)) { + if (!info.isFile()) { + return 'foreign' + } + return agentConfigDigest([ + { path: AGENT_CONFIG_SELF_PATH, executable: false, bytes: await readFile(path) } + ]) + } + if (!info.isDirectory()) { + return 'foreign' + } + const entries: AgentConfigDigestEntry[] = [] + const visit = async (dir: string, prefix: string): Promise => { + for (const entry of await readdir(dir, { withFileTypes: true })) { + const rel = prefix ? `${prefix}/${entry.name}` : entry.name + const full = join(dir, entry.name) + if (entry.isDirectory()) { + if (!(await visit(full, rel))) { + return false + } + } else if (entry.isFile()) { + const stat = await lstat(full) + entries.push({ + path: rel, + executable: (stat.mode & 0o111) !== 0, + bytes: await readFile(full) + }) + if (entries.length > AGENT_CONFIG_LIMITS.filesPerItem * 2) { + return false + } + } else { + return false + } + } + return true + } + try { + return (await visit(path, '')) ? agentConfigDigest(entries) : 'foreign' + } catch { + return 'foreign' + } +} + +/** Decides each item before any bytes move, and removes what this computer stopped sending. */ +export async function planHostAgentConfigSync( + params: AgentConfigSyncPlanParams, + deps: HostAgentConfigSyncDeps +): Promise { + const path = ledgerPath(deps.ledgerDir, params.syncer) + const ledger = await readLedger(path) + const items: Record = {} + const wanted = new Set() + for (const item of params.items) { + const key = agentConfigItemKey(item.scope, item.kind, item.name) + wanted.add(key) + const dest = destinationOf(item, deps) + if (!dest) { + items[key] = 'no-project' + continue + } + const onDisk = await digestOnDisk(dest, item.kind) + if (onDisk === null) { + items[key] = 'needed' + } else if (onDisk === item.digest) { + items[key] = 'unchanged' + ledger.items[key] = item.digest + } else if (ledger.items[key] === onDisk) { + items[key] = 'needed' + } else { + // Made or edited in the sandbox: it's the user's now. + items[key] = 'kept-host' + delete ledger.items[key] + } + } + let removed = 0 + for (const [key, digest] of Object.entries(ledger.items)) { + if (wanted.has(key)) { + continue + } + delete ledger.items[key] + const id = parseKey(key) + const dest = id ? destinationOf(id, deps) : null + // Only an untouched copy goes; an edited one stays as the user's. + if (id && dest && (await digestOnDisk(dest, id.kind)) === digest) { + await rm(dest, { recursive: true, force: true }) + removed += 1 + } + } + await writeLedger(path, ledger) + return { items, removed } +} + +function decodeFiles(item: AgentConfigItemPayload): AgentConfigDigestEntry[] | null { + const isFileKind = AGENT_CONFIG_FILE_KINDS.has(item.kind) + if (isFileKind && (item.files.length !== 1 || item.files[0].path !== AGENT_CONFIG_SELF_PATH)) { + return null + } + const paths = new Set() + const entries: AgentConfigDigestEntry[] = [] + let total = 0 + for (const file of item.files) { + if ((!isFileKind && file.path === AGENT_CONFIG_SELF_PATH) || paths.has(file.path)) { + return null + } + paths.add(file.path) + const bytes = Buffer.from(file.base64, 'base64') + total += bytes.length + if (bytes.length > AGENT_CONFIG_LIMITS.fileBytes || total > AGENT_CONFIG_LIMITS.itemBytes) { + return null + } + entries.push({ path: file.path, executable: !isFileKind && file.executable, bytes }) + } + if (!isFileKind && !paths.has('SKILL.md')) { + return null + } + return agentConfigDigest(entries) === item.digest ? entries : null +} + +async function writeItem( + dest: string, + kind: AgentConfigItemKind, + files: AgentConfigDigestEntry[] +): Promise { + const parent = dirname(dest) + await mkdir(parent, { recursive: true }) + const tag = randomBytes(6).toString('hex') + if (AGENT_CONFIG_FILE_KINDS.has(kind)) { + writeFileAtomically(dest, files[0].bytes, { mode: 0o644 }) + return + } + // Built beside the target, then swapped in, so an agent never reads half a skill. + const staged = join(parent, `.orca-sync-${tag}`) + try { + for (const file of files) { + const target = resolve(staged, file.path) + if (isAbsolute(file.path) || !target.startsWith(`${staged}/`)) { + throw new Error('Path escapes the skill folder.') + } + await mkdir(dirname(target), { recursive: true }) + await writeFile(target, file.bytes, { mode: file.executable ? 0o755 : 0o644 }) + } + const old = join(parent, `.orca-sync-old-${tag}`) + const existed = await lstat(dest).then( + () => true, + () => false + ) + if (existed) { + await rename(dest, old) + } + await rename(staged, dest) + if (existed) { + await rm(old, { recursive: true, force: true }) + } + } finally { + await rm(staged, { recursive: true, force: true }) + } +} + +/** Writes items the plan asked for. Rechecks ownership, so a file edited since the plan stays. */ +export async function putHostAgentConfig( + params: AgentConfigSyncPutParams, + deps: HostAgentConfigSyncDeps +): Promise { + const path = ledgerPath(deps.ledgerDir, params.syncer) + const ledger = await readLedger(path) + const items: Record = {} + for (const item of params.items) { + const key = agentConfigItemKey(item.scope, item.kind, item.name) + const id = parseKey(key) + const files = id ? decodeFiles(item) : null + if (!id || !files) { + items[key] = 'invalid' + continue + } + const dest = destinationOf(id, deps) + if (!dest) { + items[key] = 'no-project' + continue + } + try { + const onDisk = await digestOnDisk(dest, id.kind) + if (onDisk !== null && onDisk !== item.digest && ledger.items[key] !== onDisk) { + items[key] = 'kept-host' + continue + } + if (onDisk !== item.digest) { + await writeItem(dest, id.kind, files) + } + if (id.scope === 'project' && deps.projectPath) { + await excludeFromGit(deps.projectPath, dest, isSkillKind(id.kind)) + } + ledger.items[key] = item.digest + items[key] = onDisk === null ? 'added' : 'updated' + } catch { + items[key] = 'failed' + } + } + await writeLedger(path, ledger) + const counts = Object.values(items).reduce>((acc, outcome) => { + acc[outcome] = (acc[outcome] ?? 0) + 1 + return acc + }, {}) + console.info( + `[agent-config-sync] ${Object.entries(counts) + .map(([outcome, n]) => `${outcome}=${n}`) + .join(',')}` + ) + return { items } +} diff --git a/src/main/agent-mcp-sync/desktop/cloud-mcp-sync.ts b/src/main/agent-mcp-sync/desktop/cloud-mcp-sync.ts index 34056e67a44..da47d8e9391 100644 --- a/src/main/agent-mcp-sync/desktop/cloud-mcp-sync.ts +++ b/src/main/agent-mcp-sync/desktop/cloud-mcp-sync.ts @@ -1,4 +1,3 @@ -import { randomBytes } from 'node:crypto' import { readFileSync } from 'node:fs' import { homedir } from 'node:os' import { join } from 'node:path' @@ -18,6 +17,7 @@ import { environmentHandleFromRecipeResult } from '../../environment-providers/e import { HOSTED_SANDBOX_DRIVER_ID } from '../../hosted-sandbox/hosted-sandbox-driver' import { readLocalMcpConfig, type LocalMcpConfig } from './local-mcp-config-read' import type { CloudMcpEgress } from './cloud-mcp-egress' +import { readOrCreateSyncerId } from '../../agent-config-sync/desktop/syncer-id' const SYNC_TIMEOUT_MS = 30_000 const MAX_EXCLUDED = 512 @@ -146,30 +146,7 @@ export function createCloudMcpSync(deps: CloudMcpSyncDeps): CloudMcpSync { } } - let syncer: string | null = null - /** This computer's stable sync identity (random, not a device fingerprint). */ - function syncerId(): string { - if (syncer) { - return syncer - } - const path = join(deps.userDataPath, 'mcp-sync-syncer-id') - try { - const stored = readFileSync(path, 'utf8').trim() - if (/^[a-f0-9]{16}$/.test(stored)) { - syncer = stored - return stored - } - } catch { - // First sync from this computer. - } - syncer = randomBytes(8).toString('hex') - try { - writeFileAtomically(path, `${syncer}\n`) - } catch { - // Unwritable profile: this run still syncs as itself; the next launch gets a new id. - } - return syncer - } + const syncerId = (): Promise => readOrCreateSyncerId(deps.userDataPath) async function plan(environmentId: string) { const runtime = cloudRuntime(environmentId) @@ -180,7 +157,7 @@ export function createCloudMcpSync(deps: CloudMcpSyncDeps): CloudMcpSync { repoServerNames: local.repoServerNames, homeDir: homedir() }) - return { ...planned, params: { ...planned.params, syncer: syncerId() } } + return { ...planned, params: { ...planned.params, syncer: await syncerId() } } } function publish(status: McpSyncStatus): McpSyncStatus { diff --git a/src/main/billing/billing-client.ts b/src/main/billing/billing-client.ts index 31cf315a419..9d717c1d38d 100644 --- a/src/main/billing/billing-client.ts +++ b/src/main/billing/billing-client.ts @@ -141,7 +141,10 @@ const EntitlementSchema = z.object({ interval: z.enum(ORCA_BILLING_INTERVALS).nullable().catch(null), seats: seconds, seatChange: z - .object({ seatsAtRenewal: z.number().int().min(1), effectiveAt: z.number() }) + .object({ + seatsAtRenewal: z.number().int().min(1), + effectiveAt: z.number() + }) .nullable() .catch(null), period: window, @@ -172,7 +175,13 @@ const EntitlementSchema = z.object({ spentCents: seconds, centsPerHour: seconds }) - .catch({ optedIn: false, active: false, spendCapCents: 0, spentCents: 0, centsPerHour: 0 }), + .catch({ + optedIn: false, + active: false, + spendCapCents: 0, + spentCents: 0, + centsPerHour: 0 + }), payment: z .object({ pastDueSince: z.number().nullable().catch(null), diff --git a/src/main/billing/billing-service.ts b/src/main/billing/billing-service.ts index 89d92d3fa96..c150019aa9a 100644 --- a/src/main/billing/billing-service.ts +++ b/src/main/billing/billing-service.ts @@ -11,7 +11,8 @@ import type { OrcaBillingOverageResult, OrcaBillingStatusResult, OrcaBillingTeamPlansResult, - OrcaBillingTrialClaimResult + OrcaBillingTrialClaimResult, + OrcaBillingUsageHistoryResult } from '../../shared/orca-billing' import { getOrcaCloudAuthConfig } from '../orca-profiles/profile-cloud-auth-config' import { runWithFreshOrcaCloudSession } from '../orca-profiles/profile-cloud-session-refresh' @@ -28,6 +29,7 @@ import { type BillingEndpoints } from './billing-client' import { getBillingEndpoints } from './billing-config' +import { fetchUsageHistory } from './billing-usage-client' import { getBillingDevKeyFile, mintDevBillingToken } from './billing-dev-token' import { cleanCloudServiceUrl } from '../../shared/cloud-service-url' import { listOrcaProfileOrgMembers } from '../orca-profiles/profile-cloud-org-members-service' @@ -55,7 +57,10 @@ function prepareDev(userDataPath: string, keyFile: string): Ready { if (!cloud) { return { ok: false, status: 'signed-out' } } - const endpoints: BillingEndpoints = { billingApiUrl, billingTokenEndpoint: billingApiUrl } + const endpoints: BillingEndpoints = { + billingApiUrl, + billingTokenEndpoint: billingApiUrl + } return { ok: true, run: async (call) => { @@ -139,6 +144,25 @@ export async function getOrcaBillingStatus(userDataPath: string): Promise { + const ready = prepare(userDataPath) + if (!ready.ok) { + return { status: ready.status } + } + try { + const history = await ready.run((token, endpoints) => + fetchUsageHistory(endpoints, token, utcOffsetMinutes) + ) + return history === 'signed-out' ? { status: 'signed-out' } : { status: 'ok', history } + } catch (error) { + return { status: 'failed', error: message(error) } + } +} + /** Plan state for other teams the signed-in user is on (cloud start B2); never switches teams. */ export async function getOrcaBillingTeamPlans( userDataPath: string, diff --git a/src/main/billing/billing-usage-client.test.ts b/src/main/billing/billing-usage-client.test.ts new file mode 100644 index 00000000000..342838d7cb7 --- /dev/null +++ b/src/main/billing/billing-usage-client.test.ts @@ -0,0 +1,72 @@ +import { describe, expect, it } from 'vitest' +import { fetchUsageHistory } from './billing-usage-client' + +const endpoints = { + billingApiUrl: 'https://billing.example.test', + billingTokenEndpoint: 'https://login.example.test/v1/desktop/auth/billing-token' +} + +type Seen = { url: string; init: RequestInit | undefined } + +function fakeFetch(responses: Record, seen: Seen[] = []): typeof fetch { + return async (input, init) => { + const url = String(input) + seen.push({ url, init }) + const response = responses[url] + if (!response) { + throw new Error(`unexpected ${url}`) + } + return response + } +} + +describe('fetchUsageHistory', () => { + const url = 'https://billing.example.test/v1/billing/usage?utcOffset=-480' + const body = { + days: [{ start: 1, seconds: 3600 }], + totalSeconds: 3600, + yourSeconds: 1800, + members: { top: [{ userId: 'u1', seconds: 3600 }], otherCount: 0, otherSeconds: 0 }, + sandboxes: { top: [{ sandboxId: 'sbx_1', seconds: 3600 }], otherCount: 0, otherSeconds: 0 } + } + + it('sends the local offset and maps both breakdowns to one row shape', async () => { + const seen: Seen[] = [] + const history = await fetchUsageHistory( + endpoints, + 'bt', + -480, + fakeFetch({ [url]: Response.json(body) }, seen) + ) + expect(seen[0]!.init?.method).toBe('GET') + expect(history.members).toEqual({ + top: [{ id: 'u1', seconds: 3600 }], + otherCount: 0, + otherSeconds: 0 + }) + expect(history.sandboxes?.top).toEqual([{ id: 'sbx_1', seconds: 3600 }]) + }) + + it('accepts a member’s view and rejects malformed rows', async () => { + const member = await fetchUsageHistory( + endpoints, + 'bt', + -480, + fakeFetch({ [url]: Response.json({ ...body, members: null, sandboxes: null }) }) + ) + expect(member.members).toBeNull() + await expect( + fetchUsageHistory( + endpoints, + 'bt', + -480, + fakeFetch({ + [url]: Response.json({ + ...body, + members: { top: [{ userId: '