@shardflux/sdk 0.13.1 → 0.14.0

package/dist/client.js

@@ -3,6 +3,7 @@ import { HttpClient, SDK_VERSION, SERVER_WAIT_MAX_S, defaultFetch, defaultSleep,
 import { Workspace } from "./workspace.js";
 import { AuditApi } from "./audit.js";
 import { EgressPolicyApi } from "./egress.js";
+import { WorkspacePorts } from "./ports.js";
 import { SecretsApi } from "./secrets.js";
 import { TemplatesApi, saveAsTemplateBody } from "./templates.js";
 import { UsageApi } from "./usage.js";
@@ -46,6 +47,70 @@ function alreadyRunning(answer) {
         },
     }, 'api');
 }
+/** The `PATCH .../caps` body of a resize: the given caps only, snake_case. Throws TypeError when none is given. */
+function resizeBody(p) {
+    const body = {};
+    if (p.memoryMib !== undefined)
+        body.memory_mib = p.memoryMib;
+    if (p.memoryMibHeld !== undefined)
+        body.memory_mib_held = p.memoryMibHeld;
+    if (p.allocationMode !== undefined)
+        body.allocation_mode = p.allocationMode;
+    if (p.cpuMillis !== undefined)
+        body.cpu_millis = p.cpuMillis;
+    if (p.diskGib !== undefined)
+        body.disk_gib = p.diskGib;
+    if (Object.keys(body).length === 0)
+        throw new TypeError('resize() needs at least one of memoryMib, memoryMibHeld, allocationMode, cpuMillis, diskGib');
+    return body;
+}
+const RESIZE_KEYS = {
+    memory: ['applies_at', 'allocation_mode', 'requested_mib', 'target_mib', 'previous_mib', 'applied_mib', 'held_mib', 'converged', 'limit_reason', 'reason'],
+    cpu: ['applies_at', 'requested_millis', 'target_millis', 'previous_millis', 'applied_millis', 'limit_reason', 'reason'],
+    disk: ['applies_at', 'requested_gib', 'target_gib', 'previous_gib', 'applied_gib', 'limit_reason', 'reason'],
+};
+const record = (v) => (v !== null && typeof v === 'object' && !Array.isArray(v) ? v : {});
+/**
+ * A finished resize operation's `result` in the held answer's shape (as the API builds its 200): each resource the
+ * cell reported with its documented keys, a key the cell left out taken from the operation's input (target, requested)
+ * or null; the cell's other keys (timings, the previous values of a retried attempt) are left out.
+ */
+function resizeResultBodyOf(op) {
+    const result = record(op.result);
+    const input = record(op.input);
+    const target = record(input.target);
+    const requested = record(input.requested);
+    const fallback = {
+        memory: { allocation_mode: target.allocation_mode, requested_mib: requested.memory_mib, target_mib: target.memory_mib, held_mib: target.memory_mib_held },
+        cpu: { requested_millis: requested.cpu_millis, target_millis: target.cpu_millis },
+        disk: { requested_gib: requested.disk_gib, target_gib: target.disk_gib },
+    };
+    const out = { workspace_id: result.workspace_id ?? op.workspace_id, operation_id: op.id, state: result.state };
+    for (const [name, keys] of Object.entries(RESIZE_KEYS)) {
+        if (result[name] === null || typeof result[name] !== 'object')
+            continue;
+        const r = record(result[name]);
+        out[name] = Object.fromEntries(keys.map((k) => [k, r[k] ?? fallback[name]?.[k] ?? null]));
+    }
+    return out;
+}
+/** A resize result body (the held 200, or a finished operation's `result`) as ResizeResult. */
+function resizeResultOf(body, status, operation, workspaceId) {
+    if (!body || typeof body !== 'object' || !['memory', 'cpu', 'disk'].some((k) => body[k] && typeof body[k] === 'object')) {
+        throw new ShardfluxProtocolError('resize: the result names no resource (memory, cpu or disk)', status, 'api');
+    }
+    const part = (k) => (body[k] && typeof body[k] === 'object' ? body[k] : null);
+    return {
+        workspaceId: typeof body.workspace_id === 'string' ? body.workspace_id : workspaceId,
+        operationId: typeof body.operation_id === 'string' ? body.operation_id : (operation?.id ?? null),
+        state: typeof body.state === 'string' ? body.state : 'unknown',
+        memory: part('memory'),
+        cpu: part('cpu'),
+        disk: part('disk'),
+        caps: body.caps && typeof body.caps === 'object' ? body.caps : null,
+        operation,
+    };
+}
 /** Races the injected sleep against the signal (the injected sleep itself may not be abortable). */
 function abortableSleep(sleep, ms, signal) {
     if (signal.aborted)
@@ -316,6 +381,10 @@ export class WorkspacesApi {
     async get(workspaceId, opts = {}) {
         return this.#wrap(await this.#getView(workspaceId), opts);
     }
+    /** The exposed ports of a workspace by id (0.14.0; the same as `workspace.ports` without reading the workspace first). */
+    ports(workspaceId) {
+        return new WorkspacePorts(this.#ctx(), workspaceId);
+    }
     /** Replace labels. An empty map clears them. */
     async setLabels(workspaceId, labels) {
         return this.#wrap(await this.#http.json('PUT', `/v1/workspaces/${encodeURIComponent(workspaceId)}/labels`, { json: { labels } }, this.#auth));
@@ -514,6 +583,85 @@ export class WorkspacesApi {
     async cancelSuspendWhenIdle(workspaceId) {
         return this.#wrap(await this.#http.json('DELETE', `/v1/workspaces/${encodeURIComponent(workspaceId)}/suspend-when-idle`, {}, this.#auth));
     }
+    /**
+     * Resizes a workspace (0.14.0; `PATCH /v1/workspaces/{id}/caps`): any of memory, the held floor, the allocation mode,
+     * CPU and disk, of a running, suspended or stopped workspace, fixed or elastic, without a restart or a fork. The new
+     * caps are stored, so every later start uses them. Resolves once the resize has finished, with what applied per
+     * resource: `now` (live), `resume` (a suspended workspace gets it when it resumes, before its first call) or
+     * `next_start` (with the `reason`). The request is held by the server while the resize runs; a resize still running
+     * after the hold is waited for like any operation.
+     *
+     * A resize that meets another lifecycle operation (409 `operation_in_progress`: a suspend, a resume, another resize)
+     * waits for it and is sent again, within `timeoutMs`.
+     *
+     * Errors: ShardfluxApiError 409 `conflict` (reason `resize_not_available`, `workspace_deleted`), 422
+     * `validation_failed` (reason `shrink_not_supported` with `details.current_disk_gib`, `requires_elastic`,
+     * `exceeds_memory_mib`, `allocation_mode_not_available`, `not_supported_for_mode`). A resize that fails is its
+     * error: ShardfluxApiError with `operationId` when the server held the request until then, OperationFailedError when
+     * the SDK waited for the operation. OperationTimeoutError after `timeoutMs`. Params without a resource throw
+     * TypeError before any request.
+     *
+     *   const r = await cloud.workspaces.resize(id, { memoryMib: 6144 });
+     *   r.memory?.applies_at; // 'now'
+     */
+    async resize(workspaceId, params) {
+        const body = resizeBody(params);
+        const trace = new Trace('resize', combineListeners(this.#ctx().onProgress, params.onProgress), { workspaceId });
+        return traced(trace, async () => {
+            const timeoutMs = params.timeoutMs ?? 300_000;
+            const started = Date.now();
+            const left = () => Math.max(1, timeoutMs - (Date.now() - started));
+            const idempotencyKey = params.idempotencyKey ?? randomId('op-');
+            const path = `/v1/workspaces/${encodeURIComponent(workspaceId)}/caps`;
+            let res;
+            for (let attempt = 0;; attempt += 1) {
+                const waitS = Math.min(SERVER_WAIT_MAX_S, Math.floor((attempt === 0 ? timeoutMs : left()) / 1000));
+                const init = { json: body, idempotencyKey, onRetry: trace.onRetry, ...(params.signal ? { signal: params.signal } : {}) };
+                if (waitS >= 1) {
+                    // Held: the server answers once the resize has finished (200) or the wait elapsed (202).
+                    init.headers = { prefer: `wait=${waitS}` };
+                    init.timeoutMs = Math.max(this.#http.opts.timeoutMs, waitS * 1000 + 10_000);
+                }
+                trace.phase('request', waitS >= 1 ? 'held' : attempt === 0 ? null : 'retry');
+                try {
+                    res = await this.#http.jsonWithStatus('PATCH', path, init, this.#auth);
+                    break;
+                }
+                catch (e) {
+                    // Another lifecycle operation (a suspend, a resume, another resize) holds the workspace: the refused request
+                    // changed nothing, so wait for that operation and send it again (bounded, within timeoutMs).
+                    const active = e instanceof ShardfluxApiError && e.code === 'conflict' && e.reason === 'operation_in_progress' ? (e.operationId ?? e.details?.['active_operation_id']) : undefined;
+                    if (typeof active !== 'string' || attempt >= 3 || Date.now() - started >= timeoutMs)
+                        throw e;
+                    trace.retry({ request: `PATCH ${path}`, attempt: attempt + 1, cause: `conflict operation_in_progress (waits for ${active})`, delayMs: 0 });
+                    try {
+                        await this.waitForOperation(active, { timeoutMs: left(), ...(params.signal ? { signal: params.signal } : {}), [TRACE]: trace });
+                    }
+                    catch (w) {
+                        if (!(w instanceof OperationFailedError))
+                            throw w;
+                    }
+                }
+            }
+            if (res.status !== 202)
+                return resizeResultOf(res.body, res.status, null, workspaceId);
+            const operation = res.body?.operation;
+            if (!operation || typeof operation !== 'object')
+                throw new ShardfluxProtocolError('resize: 202 response has no operation', res.status, 'api');
+            trace.observe(operation);
+            let final = operation;
+            if (operation.state !== 'succeeded') {
+                if (TERMINAL.has(operation.state))
+                    throw new OperationFailedError(operation);
+                const wait = { timeoutMs: Math.max(1, timeoutMs - (Date.now() - started)), ...(params.signal ? { signal: params.signal } : {}), [TRACE]: trace };
+                final = await this.waitForOperation(operation.id, wait);
+            }
+            // The finished operation's result is the cell's: shaped like the held answer, whose caps come from the view.
+            const result = resizeResultBodyOf(final);
+            const view = await trace.span('view', () => this.#getView(workspaceId, trace.onRetry));
+            return resizeResultOf({ ...result, state: result.state ?? view.observed_state, caps: view.caps }, res.status, final, workspaceId);
+        });
+    }
     async close(workspaceId, opts = {}) {
         return (await this.closeWithView(workspaceId, opts)).operation;
     }

package/dist/codex-proof.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Codex identity proof (0.14.0+, Node): the OpenAI ID token of the Codex CLI signed in on this machine, for
+ * `ShardfluxAccount.signup({ codexIdToken })` and `auth.stepUp({ codexIdToken })`.
+ *
+ * Codex keeps the token in `$CODEX_HOME/auth.json` (default `~/.codex/auth.json`) and refreshes it only every few
+ * days, while the API accepts one issued in the last 15 minutes. So this first asks Codex to refresh its own login
+ * (`codex app-server`, JSON-RPC `account/read {"refreshToken": true}`: Codex runs its normal refresh flow and writes
+ * its own file), then reads the token. Only the ID token is returned: Codex's access and refresh tokens are never read
+ * into memory beyond parsing the file, and never leave the machine. The ID token proves the ChatGPT account's verified
+ * email; it is not a credential to OpenAI.
+ *
+ *   const proof = await codexIdentityProof();
+ *   if (proof.ok) {
+ *     const { account, result } = await ShardfluxAccount.signup({ codexIdToken: proof.idToken });
+ *   }
+ */
+export type CodexProofUnavailable = 
+/** No `codex` executable on PATH (or CODEX_BIN), and no usable auth.json. */
+'codex_not_found'
+/** Codex is not signed in (no auth.json, or no ID token in it: signed in with an API key, or credentials in the OS keyring). */
+ | 'not_signed_in'
+/** Codex is signed in with an OpenAI API key, which carries no identity. */
+ | 'api_key_login'
+/** The token on disk is too old and Codex could not refresh it. */
+ | 'stale';
+export type CodexIdentityProof = {
+    ok: true;
+    idToken: string;
+    email: string | null;
+    refreshed: boolean;
+} | {
+    ok: false;
+    reason: CodexProofUnavailable;
+    message: string;
+};
+export interface CodexProofOptions {
+    /** Environment to read CODEX_HOME, CODEX_BIN and HOME from. Default `process.env`. */
+    env?: Record<string, string | undefined>;
+    /** Longest wait for `codex app-server` (ms). Default 15 000. */
+    timeoutMs?: number;
+    /** Skip the refresh and only read the file (tests, or when Codex must not be started). */
+    refresh?: boolean;
+    /** Accept a token issued at most this long ago (s), e.g. when Codex cannot refresh. Default 600 (the API allows 900). */
+    maxAgeSeconds?: number;
+    /** clientInfo sent to the app server. */
+    clientName?: string;
+    clientVersion?: string;
+}
+/**
+ * The ID token of this machine's Codex login, refreshed by Codex when needed. Never throws: `{ ok: false, reason }`
+ * says why there is none (sign up with an email address instead).
+ */
+export declare function codexIdentityProof(opts?: CodexProofOptions): Promise<CodexIdentityProof>;

package/dist/codex-proof.js

@@ -0,0 +1,200 @@
+/**
+ * Codex identity proof (0.14.0+, Node): the OpenAI ID token of the Codex CLI signed in on this machine, for
+ * `ShardfluxAccount.signup({ codexIdToken })` and `auth.stepUp({ codexIdToken })`.
+ *
+ * Codex keeps the token in `$CODEX_HOME/auth.json` (default `~/.codex/auth.json`) and refreshes it only every few
+ * days, while the API accepts one issued in the last 15 minutes. So this first asks Codex to refresh its own login
+ * (`codex app-server`, JSON-RPC `account/read {"refreshToken": true}`: Codex runs its normal refresh flow and writes
+ * its own file), then reads the token. Only the ID token is returned: Codex's access and refresh tokens are never read
+ * into memory beyond parsing the file, and never leave the machine. The ID token proves the ChatGPT account's verified
+ * email; it is not a credential to OpenAI.
+ *
+ *   const proof = await codexIdentityProof();
+ *   if (proof.ok) {
+ *     const { account, result } = await ShardfluxAccount.signup({ codexIdToken: proof.idToken });
+ *   }
+ */
+function claimsOf(token) {
+    const part = token.split('.')[1];
+    if (!part)
+        return null;
+    try {
+        return JSON.parse(Buffer.from(part, 'base64url').toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function fresh(token, maxAgeSeconds) {
+    const c = claimsOf(token);
+    const now = Date.now() / 1000;
+    return c !== null && typeof c.iat === 'number' && typeof c.exp === 'number' && now - c.iat <= maxAgeSeconds && c.exp - now > 60;
+}
+async function codexHome(env) {
+    const path = await import('node:path');
+    const os = await import('node:os');
+    const set = env.CODEX_HOME?.trim();
+    return set ? path.resolve(set) : path.join(env.HOME?.trim() || os.homedir(), '.codex');
+}
+/** `tokens.id_token` of auth.json, or null (missing file, other shape, API-key login). */
+async function readIdToken(home) {
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    let raw;
+    try {
+        raw = await fs.readFile(path.join(home, 'auth.json'), 'utf8');
+    }
+    catch {
+        return { token: null, apiKeyOnly: false, exists: false };
+    }
+    try {
+        const doc = JSON.parse(raw);
+        const token = typeof doc.tokens?.id_token === 'string' && doc.tokens.id_token.length > 0 ? doc.tokens.id_token : null;
+        const apiKeyOnly = token === null && (doc.auth_mode === 'apikey' || (typeof doc.OPENAI_API_KEY === 'string' && doc.OPENAI_API_KEY.length > 0));
+        return { token, apiKeyOnly, exists: true };
+    }
+    catch {
+        return { token: null, apiKeyOnly: false, exists: true };
+    }
+}
+/**
+ * The `codex` executables to try, in PATH order (CODEX_BIN alone when set). Every match is kept, not only the first:
+ * npx puts ancestor node_modules/.bin directories first on PATH, where an unrelated npm package named `codex` can
+ * shadow the Codex CLI. Distinct by real path.
+ */
+async function codexCandidates(env) {
+    const set = env.CODEX_BIN?.trim();
+    if (set)
+        return [set];
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    const names = process.platform === 'win32' ? ['codex.exe', 'codex.cmd', 'codex'] : ['codex'];
+    const out = [];
+    const seen = new Set();
+    for (const dir of (env.PATH ?? '').split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const name of names) {
+            const file = path.join(dir, name);
+            try {
+                await fs.access(file, fs.constants.X_OK);
+                const real = await fs.realpath(file);
+                if (seen.has(real))
+                    continue;
+                seen.add(real);
+                out.push(file);
+            }
+            catch {
+                // not there, or not executable
+            }
+        }
+    }
+    return out;
+}
+/** Asks Codex to refresh its own login through the app server of the first candidate that speaks its protocol. */
+async function refreshViaAppServer(env, opts) {
+    const candidates = await codexCandidates(env);
+    if (candidates.length === 0)
+        return 'not_found';
+    let outcome = 'not_found';
+    for (const bin of candidates.slice(0, 4)) {
+        outcome = await appServerRefresh(bin, env, opts);
+        if (outcome !== 'failed' && outcome !== 'not_found')
+            return outcome;
+    }
+    return outcome;
+}
+async function appServerRefresh(bin, env, opts) {
+    const { spawn } = await import('node:child_process');
+    return new Promise((resolve) => {
+        let settled = false;
+        let buffer = '';
+        const child = spawn(bin, ['app-server'], { stdio: ['pipe', 'pipe', 'ignore'], env, windowsHide: true });
+        const done = (o) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.stdin.end();
+            child.kill();
+            resolve(o);
+        };
+        const timer = setTimeout(() => done('failed'), opts.timeoutMs);
+        const send = (msg) => child.stdin.write(`${JSON.stringify(msg)}\n`);
+        child.on('error', (err) => done(err.code === 'ENOENT' ? 'not_found' : 'failed'));
+        child.on('exit', () => done('failed'));
+        child.stdin.on('error', () => done('failed'));
+        child.stdout.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            buffer += chunk;
+            let nl;
+            while ((nl = buffer.indexOf('\n')) >= 0) {
+                const line = buffer.slice(0, nl).trim();
+                buffer = buffer.slice(nl + 1);
+                if (line.length === 0)
+                    continue;
+                let msg;
+                try {
+                    msg = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (msg.id === 1) {
+                    if (msg.error !== undefined)
+                        return done('failed');
+                    send({ jsonrpc: '2.0', method: 'initialized' });
+                    send({ jsonrpc: '2.0', id: 2, method: 'account/read', params: { refreshToken: true } });
+                }
+                else if (msg.id === 2) {
+                    if (msg.error !== undefined)
+                        return done('failed');
+                    const type = msg.result?.account?.type;
+                    return done(type === 'chatgpt' ? 'refreshed' : type === 'apiKey' ? 'api_key_login' : type === undefined || type === null ? 'not_signed_in' : 'failed');
+                }
+            }
+        });
+        send({ jsonrpc: '2.0', id: 1, method: 'initialize', params: { clientInfo: { name: opts.clientName, version: opts.clientVersion } } });
+    });
+}
+/**
+ * The ID token of this machine's Codex login, refreshed by Codex when needed. Never throws: `{ ok: false, reason }`
+ * says why there is none (sign up with an email address instead).
+ */
+export async function codexIdentityProof(opts = {}) {
+    const env = opts.env ?? process.env;
+    const maxAge = opts.maxAgeSeconds ?? 600;
+    const home = await codexHome(env);
+    let outcome = 'skipped';
+    // Always refresh first: each refresh mints a token with a new jti, and the API accepts each jti once, so a token
+    // still fresh on disk may already have been used. The file alone is the fallback when Codex cannot refresh.
+    let file = await readIdToken(home);
+    let renewed = false;
+    if (opts.refresh !== false) {
+        const appServer = { timeoutMs: opts.timeoutMs ?? 15_000, clientName: opts.clientName ?? 'shardflux', clientVersion: opts.clientVersion ?? '0' };
+        const before = file.token;
+        // A refresh counts only when the token on disk changed. One retry: a refresh can fail on a transient network
+        // error, answer without renewing, or race another Codex process refreshing the same login.
+        for (let attempt = 0; attempt < 2 && !renewed; attempt++) {
+            if (attempt > 0)
+                await new Promise((r) => setTimeout(r, 500));
+            outcome = await refreshViaAppServer(env, appServer);
+            file = await readIdToken(home);
+            renewed = file.token !== null && file.token !== before && fresh(file.token, maxAge);
+            if (outcome === 'api_key_login' || outcome === 'not_signed_in' || outcome === 'not_found')
+                break;
+        }
+    }
+    if (file.token !== null && fresh(file.token, maxAge)) {
+        const email = claimsOf(file.token)?.email;
+        return { ok: true, idToken: file.token, email: typeof email === 'string' ? email : null, refreshed: renewed };
+    }
+    if (outcome === 'api_key_login' || file.apiKeyOnly)
+        return { ok: false, reason: 'api_key_login', message: 'Codex is signed in with an API key, which carries no identity. Sign in with ChatGPT (codex login), or sign up with an email address.' };
+    if (outcome === 'not_signed_in' || (file.token === null && outcome !== 'not_found')) {
+        return { ok: false, reason: 'not_signed_in', message: 'Codex is not signed in with ChatGPT on this machine (codex login), or keeps its login in the OS keyring. Sign up with an email address instead.' };
+    }
+    if (outcome === 'not_found' && !file.exists)
+        return { ok: false, reason: 'codex_not_found', message: 'The Codex CLI is not installed (or not on PATH). Sign up with an email address instead.' };
+    return { ok: false, reason: 'stale', message: 'The Codex login on this machine could not be refreshed. Run any codex command (or codex login), then try again.' };
+}

package/dist/errors.d.ts

@@ -82,7 +82,7 @@ export type ErrorCode = AppErrorCode | CellErrorCode;
  * `retained_state` (details.limit_value and details.current in GiB) when opening a new key or forking with the plan's
  * Retained state used up. `details.limit` is not a reason: these are not in this union.
  */
-export type KnownErrorReason = 'invalid_recipe' | 'base_not_layered' | 'language_unavailable' | 'language_conflict' | 'invalid_package' | 'too_many_files' | 'platform_owned_path' | 'upload_required' | 'upload_missing' | 'upload_digest_mismatch' | 'upload_too_large' | 'extra_hosts_without_auto' | 'invalid_settings' | 'services_unsupported' | 'input_required' | 'input_unknown' | 'input_invalid' | 'egress_widening' | 'reserved_session_id' | 'env_collision' | 'reserved_template_slug' | 'package_index_unavailable' | 'package_not_found' | 'startup_failed' | 'service_not_ready' | 'secrets_unavailable' | 'workspace_not_running' | 'operation_in_progress' | 'workspace_deleted' | 'secret_not_available' | 'legacy_disk_layout' | 'not_session' | 'session_lifetime' | 'lifetime_mismatch' | 'not_resettable' | 'template_not_layered' | 'draft_exists' | 'draft_stale' | 'build_in_progress' | 'file_list_unavailable' | 'file_list_indexing' | 'guest_feature_unavailable' | 'confirm_destructive_required' | 'reserved_key_prefix' | 'invalid_defaults' | 'invalid_path' | 'too_many_acknowledged_findings' | 'template_dev_mode_role' | 'draft_not_found' | 'version_not_found' | 'path_not_found' | 'revision_mismatch' | 'edit_not_found' | 'edit_ambiguous' | 'edit_not_text' | 'patch_invalid' | 'host_capacity' | 'wake_failed' | 'workspace_fenced' | 'offline_unavailable' | 'offline_budget' | 'offline_changed' | 'host_feature_unavailable' | 'not_supported_for_mode' | 'mode_mismatch' | 'mode_not_available' | 'layout_unsupported' | 'tree_revision_mismatch' | 'outside_tree_root' | 'execution_in_progress' | 'execution_id_reused' | 'operation_id_reused' | 'no_execution_host' | 'lease_expired' | 'host_unreachable' | 'host_restarted' | 'tree_moved' | 'blob_missing' | 'blob_corrupt' | 'exec_failed_to_start' | 'invalid_cwd' | 'allowance_used' | 'overage_paused' | 'spend_cap_reached' | 'overage_unavailable' | 'spend_cap_required' | 'spend_cap_below_minimum' | 'spend_cap_above_plan_price' | 'spend_cap_below_charges' | 'version_mismatch' | 'allocation_mode_not_available' | 'requires_elastic' | 'exceeds_memory_mib' | 'burst_mode_not_supported' | 'burst_not_supported' | 'burst_size_exceeds_plan' | 'not_available' | 'shared_volumes' | 'fence_not_drained' | 'apply_pending' | 'park_failed' | 'workspace_resumed' | 'interrupted' | 'burst_lost' | 'disk_full' | 'apply_failed' | 'reverted' | 'revert_failed' | 'immutable_path_removed' | 'immutable_paths_unsupported_base' | 'read_only_path' | 'host_lost';
+export type KnownErrorReason = 'invalid_recipe' | 'base_not_layered' | 'language_unavailable' | 'language_conflict' | 'invalid_package' | 'too_many_files' | 'platform_owned_path' | 'upload_required' | 'upload_missing' | 'upload_digest_mismatch' | 'upload_too_large' | 'extra_hosts_without_auto' | 'invalid_settings' | 'services_unsupported' | 'input_required' | 'input_unknown' | 'input_invalid' | 'egress_widening' | 'reserved_session_id' | 'env_collision' | 'reserved_template_slug' | 'package_index_unavailable' | 'package_not_found' | 'startup_failed' | 'service_not_ready' | 'secrets_unavailable' | 'workspace_not_running' | 'operation_in_progress' | 'workspace_deleted' | 'secret_not_available' | 'legacy_disk_layout' | 'not_session' | 'session_lifetime' | 'lifetime_mismatch' | 'not_resettable' | 'template_not_layered' | 'draft_exists' | 'draft_stale' | 'build_in_progress' | 'file_list_unavailable' | 'file_list_indexing' | 'guest_feature_unavailable' | 'confirm_destructive_required' | 'reserved_key_prefix' | 'invalid_defaults' | 'invalid_path' | 'too_many_acknowledged_findings' | 'template_dev_mode_role' | 'draft_not_found' | 'version_not_found' | 'path_not_found' | 'revision_mismatch' | 'edit_not_found' | 'edit_ambiguous' | 'edit_not_text' | 'patch_invalid' | 'host_capacity' | 'wake_failed' | 'workspace_fenced' | 'offline_unavailable' | 'offline_budget' | 'offline_changed' | 'host_feature_unavailable' | 'not_supported_for_mode' | 'mode_mismatch' | 'mode_not_available' | 'layout_unsupported' | 'tree_revision_mismatch' | 'outside_tree_root' | 'execution_in_progress' | 'execution_id_reused' | 'operation_id_reused' | 'no_execution_host' | 'lease_expired' | 'host_unreachable' | 'host_restarted' | 'tree_moved' | 'blob_missing' | 'blob_corrupt' | 'exec_failed_to_start' | 'invalid_cwd' | 'allowance_used' | 'overage_paused' | 'spend_cap_reached' | 'overage_unavailable' | 'spend_cap_required' | 'spend_cap_below_minimum' | 'spend_cap_above_plan_price' | 'spend_cap_below_charges' | 'version_mismatch' | 'allocation_mode_not_available' | 'requires_elastic' | 'exceeds_memory_mib' | 'burst_mode_not_supported' | 'burst_not_supported' | 'burst_size_exceeds_plan' | 'not_available' | 'shared_volumes' | 'fence_not_drained' | 'apply_pending' | 'park_failed' | 'workspace_resumed' | 'interrupted' | 'burst_lost' | 'disk_full' | 'apply_failed' | 'reverted' | 'revert_failed' | 'immutable_path_removed' | 'immutable_paths_unsupported_base' | 'read_only_path' | 'resize_not_available' | 'shrink_not_supported' | 'resize_failed' | 'host_lost' | 'inbound_ports_not_available' | 'port_not_exposed' | 'port_limit';
 /** A known reason, or any other string the server sends (reasons are open-ended). */
 export type ErrorReason = KnownErrorReason | (string & {});
 export interface ErrorBodyLike {