@vibesdotdev/platform 0.0.0-stage → 1.0.0-rc.2

package/dist/client/http.js

@@ -0,0 +1,911 @@
+import * as R from "../schemas/http-responses.js";
+import { CapabilityError, CaughtFailureSchema, isCapabilityError, settle, settleNow, valueFreeFailure } from '@vibesdotdev/kernel';
+import * as z from 'zod/v4';
+import { platformNotSignedInError } from "../api/platform.api-client.types.js";
+import { provisionHostResponseJsonSchema } from "../schemas/hosts/provision.js";
+async function platformHttpOrigin(options) {
+    return ((await options.resolveOrigin?.()) ?? options.origin).replace(/\/$/, '');
+}
+function createApiClient(options) {
+    const fetchFn = options.fetch ?? globalThis.fetch;
+    return async function request(path, init, schema) {
+        const url = `${await platformHttpOrigin(options)}${path}`;
+        const headers = new Headers(await options.resolveHeaders?.());
+        for (const [name, value] of new Headers(options.headers))
+            headers.set(name, value);
+        for (const [name, value] of new Headers(init?.headers))
+            headers.set(name, value);
+        const transport = await settle(() => fetchFn(url, {
+            ...init,
+            headers,
+            credentials: init?.credentials ?? options.credentials ?? 'include'
+        }));
+        if (!transport.ok) {
+            if (isCapabilityError(transport.cause))
+                throw transport.cause;
+            throw new CapabilityError('The Platform request could not be completed.', 'UNAVAILABLE', {
+                reason: 'platform-request-failed', details: { failure: valueFreeFailure(transport.cause) }
+            });
+        }
+        const response = transport.value;
+        if (response.status === 401)
+            throw platformNotSignedInError();
+        if (!response.ok) {
+            throw new PlatformApiError(response.status, 'The Platform service refused the request.', path, await readRefusalBody(response));
+        }
+        try {
+            const text = response.status === 204 || response.status === 205 ? '' : await response.text();
+            return schema.parse(text ? JSON.parse(text) : undefined);
+        }
+        catch (error) {
+            const failure = CaughtFailureSchema.parse(error);
+            if (isCapabilityError(failure))
+                throw failure;
+            throw new CapabilityError('The Platform service returned an invalid response.', 'UNAVAILABLE', {
+                reason: 'platform-response-invalid', details: {
+                    status: response.status, failure: valueFreeFailure(failure)
+                }
+            });
+        }
+    };
+}
+const REFUSAL_TEXT_MAX = 500;
+const RefusalBodySchema = z.looseObject({ error: z.string().optional(), message: z.string().optional() });
+/**
+ * The server's own `error`/`message` from a refusal body, bounded. Routes
+ * already sanitize these (the provision route strips the enrollment token);
+ * without them a 502 never says that the provider refused, or why.
+ */
+async function readRefusalBody(response) {
+    const text = await settle(() => response.text());
+    if (!text.ok || !text.value)
+        return {};
+    const parsed = settleNow(() => RefusalBodySchema.safeParse(JSON.parse(text.value)));
+    if (!parsed.ok || !parsed.value.success)
+        return {};
+    const bound = (value) => value?.slice(0, REFUSAL_TEXT_MAX);
+    return { error: bound(parsed.value.data.error), message: bound(parsed.value.data.message) };
+}
+/** @deprecated Match CapabilityError reasons; retained for status/path consumers. */
+export class PlatformApiError extends CapabilityError {
+    status;
+    path;
+    constructor(status, _message, path, server = {}) {
+        const said = [server.error, server.message].filter(Boolean).join(': ');
+        const withStatus = { status };
+        const withError = server.error === undefined ? withStatus : { status, serverError: server.error };
+        const details = server.message === undefined ? withError : { ...withError, serverMessage: server.message };
+        super(said ? `The Platform service refused the request (${status}): ${said}` : 'The Platform service refused the request.', 'UNAVAILABLE', {
+            reason: 'platform-request-refused',
+            details
+        });
+        this.name = 'PlatformApiError';
+        this.status = status;
+        this.path = path;
+    }
+}
+function toAbsoluteUrl(origin, url) {
+    return url.startsWith('http://') || url.startsWith('https://')
+        ? url
+        : new URL(url, `${origin}/`).toString();
+}
+function withQuery(path, params) {
+    if (!params)
+        return path;
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null || value === '')
+            continue;
+        query.set(key, String(value));
+    }
+    const queryString = query.toString();
+    return queryString ? `${path}?${queryString}` : path;
+}
+/** Decode a base64 string to an ArrayBuffer (workerd + Node both expose `atob`). */
+function base64ToArrayBuffer(b64) {
+    const binary = atob(b64);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++)
+        bytes[i] = binary.charCodeAt(i);
+    return bytes.buffer;
+}
+export function createPlatformClient(_runtime, options) {
+    const request = createApiClient(options);
+    return {
+        storage: {
+            async upload(file, opts) {
+                const query = new URLSearchParams();
+                if (opts?.projectId)
+                    query.set('projectId', opts.projectId);
+                if (opts?.storageProviderId)
+                    query.set('providerId', opts.storageProviderId);
+                if (opts?.isPublic !== undefined)
+                    query.set('isPublic', String(opts.isPublic));
+                if (opts?.retentionPolicy)
+                    query.set('retention', opts.retentionPolicy);
+                if (opts?.sourceApp)
+                    query.set('sourceApp', opts.sourceApp);
+                if (opts?.sourceId)
+                    query.set('sourceId', opts.sourceId);
+                const formData = new FormData();
+                formData.append('file', file);
+                if (opts?.title)
+                    formData.append('title', opts.title);
+                if (opts?.description)
+                    formData.append('description', opts.description);
+                if (opts?.tags)
+                    formData.append('tags', JSON.stringify(opts.tags));
+                if (opts?.metadata)
+                    formData.append('metadata', JSON.stringify(opts.metadata));
+                const queryString = query.toString();
+                const result = await request(`/api/storage/upload${queryString ? `?${queryString}` : ''}`, {
+                    method: 'POST',
+                    body: formData
+                }, R.storage_uploadResponseSchema);
+                return {
+                    ...result,
+                    url: toAbsoluteUrl(await platformHttpOrigin(options), result.url)
+                };
+            },
+            async listFiles(params) {
+                const qs = new URLSearchParams();
+                if (params?.limit)
+                    qs.set('limit', String(params.limit));
+                if (params?.offset)
+                    qs.set('offset', String(params.offset));
+                return request(`/api/storage/files?${qs}`, undefined, R.storage_listFilesResponseSchema);
+            },
+            async deleteFile(fileId) {
+                await request(`/api/storage/files/${fileId}`, { method: 'DELETE' }, R.storage_deleteFileResponseSchema);
+            },
+            getDownloadUrl(fileId) {
+                return `${options.origin}/api/storage/files/${fileId}`;
+            },
+            async listProviders(options) {
+                const query = new URLSearchParams();
+                if (options?.projectId)
+                    query.set('projectId', options.projectId);
+                if (options?.includeInactive !== undefined) {
+                    query.set('includeInactive', String(options.includeInactive));
+                }
+                const queryString = query.toString();
+                return request(`/api/storage/providers${queryString ? `?${queryString}` : ''}`, undefined, R.storage_listProvidersResponseSchema);
+            },
+            async getProvider(providerId) {
+                return request(`/api/storage/providers/${encodeURIComponent(providerId)}`, undefined, R.storage_getProviderResponseSchema);
+            },
+            async createProvider(input) {
+                return request('/api/storage/providers', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.storage_createProviderResponseSchema);
+            },
+            async updateProvider(providerId, input) {
+                return request(`/api/storage/providers/${encodeURIComponent(providerId)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.storage_updateProviderResponseSchema);
+            },
+            async deleteProvider(providerId) {
+                await request(`/api/storage/providers/${encodeURIComponent(providerId)}`, {
+                    method: 'DELETE'
+                }, R.storage_deleteProviderResponseSchema);
+            },
+            async listCollections() {
+                return request('/api/storage/collections', undefined, R.storage_listCollectionsResponseSchema);
+            },
+            async getCollection(collectionId) {
+                return request(`/api/storage/collections/${encodeURIComponent(collectionId)}`, undefined, R.storage_getCollectionResponseSchema);
+            },
+            async createCollection(input) {
+                return request('/api/storage/collections', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.storage_createCollectionResponseSchema);
+            },
+            async deleteCollection(collectionId) {
+                await request(`/api/storage/collections/${encodeURIComponent(collectionId)}`, {
+                    method: 'DELETE'
+                }, R.storage_deleteCollectionResponseSchema);
+            },
+            async addItemToCollection(collectionId, mediaItemId, options) {
+                return request(`/api/storage/collections/${encodeURIComponent(collectionId)}/items`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        mediaItemId,
+                        sortOrder: options?.sortOrder
+                    })
+                }, R.storage_addItemToCollectionResponseSchema);
+            },
+            async removeItemFromCollection(collectionId, mediaItemId) {
+                await request(`/api/storage/collections/${encodeURIComponent(collectionId)}/items/${encodeURIComponent(mediaItemId)}`, { method: 'DELETE' }, R.storage_removeItemFromCollectionResponseSchema);
+            },
+            /**
+             * Browse a `storage/adapter` that declares the `browse` capability
+             * (SharePoint, etc.). The adapter is resolved server-side within the
+             * caller's user/org runtime context, so credentialed adapters acquire
+             * their per-request token. This is the generic, runtime-resolved browse
+             * path — features consume it via the platform client, never by reaching
+             * for adapter-specific endpoints.
+             */
+            browse: {
+                async listDrives(adapterId, config) {
+                    const res = await request(withQuery(`/api/storage/adapters/${encodeURIComponent(adapterId)}/drives`, {
+                        config: config ? JSON.stringify(config) : undefined
+                    }), undefined, R.storage_browse_listDrivesResponseSchema);
+                    return res.results;
+                },
+                async list(adapterId, driveId, path, config, options) {
+                    const res = await request(withQuery(`/api/storage/adapters/${encodeURIComponent(adapterId)}/entries`, {
+                        driveId,
+                        path: path ?? '',
+                        itemId: options?.itemId,
+                        config: config ? JSON.stringify(config) : undefined
+                    }), undefined, R.storage_browse_listResponseSchema);
+                    return res.results;
+                }
+            },
+            /**
+             * Search entries within a `storage/adapter` that declares the `search`
+             * capability (e.g. SharePoint via Graph content search). The adapter is
+             * resolved server-side within the caller's session context with the same
+             * IDOR discipline as browse — raw adapter config never comes from the
+             * client.
+             */
+            search: {
+                async search(adapterId, driveId, query, opts, config) {
+                    const res = await request(withQuery(`/api/storage/adapters/${encodeURIComponent(adapterId)}/search`, {
+                        driveId,
+                        query,
+                        path: opts?.path,
+                        limit: opts?.limit,
+                        config: config ? JSON.stringify(config) : undefined
+                    }), undefined, R.storage_search_searchResponseSchema);
+                    return res.results;
+                }
+            },
+            /**
+             * The unified storage "drives" for the caller's scope — every backend
+             * (vibes default + connected providers + integration-backed SharePoint)
+             * as a target the multi-backend explorer renders. Each result carries
+             * the opaque `{ adapterId, namespace, config }` handed back to `browse`
+             * + `objects`, so no backend knowledge leaks into the UI. `scope.filter`
+             * NARROWS the default (all reachable scopes) set; it never grants access.
+             */
+            async drives(scope) {
+                const res = await request(withQuery('/api/storage/drives', {
+                    projectId: scope?.projectId,
+                    scope: scope?.filter ? JSON.stringify(scope.filter) : undefined
+                }), undefined, R.storage_drivesResponseSchema);
+                return res.results;
+            },
+            /**
+             * Generic object-protocol writes/URLs over any object-capable target
+             * (from `drives`). The adapter resolves server-side per request context
+             * with per-call config — race-safe across scopes.
+             */
+            objects: {
+                /** Upload a file to `key` within `target`. Returns the stored ref. */
+                async upload(target, key, file, opts) {
+                    const form = new FormData();
+                    form.set('providerId', target.providerId);
+                    if (target.namespace)
+                        form.set('driveId', target.namespace);
+                    form.set('key', key);
+                    if (opts?.contentType)
+                        form.set('contentType', opts.contentType);
+                    form.set('file', file);
+                    const res = await request('/api/storage/objects', {
+                        method: 'POST',
+                        body: form
+                    }, R.storage_objects_uploadResponseSchema);
+                    return res.object;
+                },
+                /** Delete the object at `key` within `target`. Idempotent. */
+                async delete(target, key) {
+                    await request('/api/storage/objects', {
+                        method: 'DELETE',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            providerId: target.providerId,
+                            driveId: target.namespace,
+                            key
+                        })
+                    }, R.storage_objects_deleteResponseSchema);
+                },
+                /** Resolve a serving URL (public / signed / proxy) for `key`. */
+                async url(target, key, opts) {
+                    const res = await request('/api/storage/objects/url', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            providerId: target.providerId,
+                            driveId: target.namespace,
+                            key,
+                            ttlSeconds: opts?.ttlSeconds,
+                            disposition: opts?.disposition
+                        })
+                    }, R.storage_objects_urlResponseSchema);
+                    return res.url;
+                },
+                /**
+                 * Read an object's bytes — for server-side ingestion (e.g. the AI
+                 * worker resolving a `storage://` ref). Returns `null` when the object
+                 * is missing. Bytes are base64-framed over the JSON transport and
+                 * decoded here to an ArrayBuffer; prefer `url()` for large binaries.
+                 */
+                async read(target, key) {
+                    const res = await request('/api/storage/objects/read', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            providerId: target.providerId,
+                            driveId: target.namespace,
+                            key
+                        })
+                    }, R.storage_objects_readResponseSchema);
+                    if (!res || res.found === false)
+                        return null;
+                    return { contentType: res.contentType, data: base64ToArrayBuffer(res.base64) };
+                }
+            }
+        },
+        databases: {
+            async list() {
+                return request('/api/databases', undefined, R.databases_listResponseSchema);
+            },
+            async get(id) {
+                const result = await request(`/api/databases/${encodeURIComponent(id)}`, undefined, R.databases_getResponseSchema);
+                return result.connection;
+            },
+            async create(input) {
+                return request('/api/databases', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.databases_createResponseSchema);
+            },
+            async update(id, input) {
+                return request(`/api/databases/${encodeURIComponent(id)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.databases_updateResponseSchema);
+            },
+            async delete(id) {
+                return request(`/api/databases/${encodeURIComponent(id)}`, {
+                    method: 'DELETE'
+                }, R.databases_deleteResponseSchema);
+            },
+            async test(id) {
+                return request(`/api/databases/${encodeURIComponent(id)}/test`, {
+                    method: 'POST'
+                }, R.databases_testResponseSchema);
+            },
+            async health(includeChecks = false) {
+                const qs = includeChecks ? '?checks=true' : '';
+                return request(`/api/databases/health${qs}`, undefined, R.databases_healthResponseSchema);
+            },
+            async healthCheckAll() {
+                return request('/api/databases/health/check-all', { method: 'POST' }, R.databases_healthCheckAllResponseSchema);
+            }
+        },
+        integrations: {
+            async list(params) {
+                const qs = new URLSearchParams();
+                if (params?.category)
+                    qs.set('category', params.category);
+                if (params?.status)
+                    qs.set('status', params.status);
+                return request(`/api/integrations?${qs}`, undefined, R.integrations_listResponseSchema);
+            },
+            async get(id) {
+                const result = await request(`/api/integrations/${encodeURIComponent(id)}`, undefined, R.integrations_getResponseSchema);
+                return result.integration;
+            },
+            async create(input) {
+                return request('/api/integrations', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.integrations_createResponseSchema);
+            },
+            async update(id, input) {
+                return request(`/api/integrations/${encodeURIComponent(id)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.integrations_updateResponseSchema);
+            },
+            async delete(id) {
+                return request(`/api/integrations/${encodeURIComponent(id)}`, {
+                    method: 'DELETE'
+                }, R.integrations_deleteResponseSchema);
+            },
+            async catalog() {
+                return request('/api/integrations/catalog', undefined, R.integrations_catalogResponseSchema);
+            },
+            async test(id) {
+                return request(`/api/integrations/${encodeURIComponent(id)}/test`, {
+                    method: 'POST'
+                }, R.integrations_testResponseSchema);
+            }
+        },
+        secrets: {
+            async list(params) {
+                return request(withQuery('/api/secrets', {
+                    scope: params?.scope,
+                    scopeId: params?.scopeId,
+                    providerType: params?.providerType,
+                    limit: params?.limit,
+                    offset: params?.offset
+                }), undefined, R.secrets_listResponseSchema);
+            },
+            async get(id) {
+                const result = await request(`/api/secrets/${encodeURIComponent(id)}`, undefined, R.secrets_getResponseSchema);
+                return result.secret;
+            },
+            async create(input) {
+                return request('/api/secrets', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.secrets_createResponseSchema);
+            },
+            async update(id, input) {
+                return request(`/api/secrets/${encodeURIComponent(id)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.secrets_updateResponseSchema);
+            },
+            async delete(id) {
+                return request(`/api/secrets/${encodeURIComponent(id)}`, {
+                    method: 'DELETE'
+                }, R.secrets_deleteResponseSchema);
+            },
+            async test(id) {
+                return request(`/api/secrets/${encodeURIComponent(id)}/test`, {
+                    method: 'POST'
+                }, R.secrets_testResponseSchema);
+            },
+            async attach(id, input) {
+                return request(`/api/${encodeURIComponent(input.resourceType)}/${encodeURIComponent(input.resourceId)}/secrets`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        secretId: id,
+                        purpose: input.purpose ?? null
+                    })
+                }, R.secrets_attachResponseSchema);
+            },
+            async rotate(id, newValue) {
+                return request(`/api/secrets/${encodeURIComponent(id)}/rotate`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ newValue })
+                }, R.secrets_rotateResponseSchema);
+            },
+            async usage(id) {
+                return request(`/api/secrets/${encodeURIComponent(id)}/usage`, undefined, R.secrets_usageResponseSchema);
+            },
+            requestUrl(params) {
+                return `${options.origin}${withQuery('/secrets/request', {
+                    title: params.title,
+                    description: params.description,
+                    providerType: params.providerType,
+                    scope: params.scope,
+                    scopeId: params.scopeId,
+                    resourceType: params.resourceType,
+                    resourceId: params.resourceId,
+                    purpose: params.purpose,
+                    returnTo: params.returnTo
+                })}`;
+            },
+            integrationRequestUrl(params) {
+                return `${options.origin}${withQuery('/integrations/request', {
+                    title: params.title,
+                    description: params.description,
+                    provider: params.provider,
+                    scope: params.scope,
+                    scopeId: params.scopeId,
+                    returnTo: params.returnTo
+                })}`;
+            }
+        },
+        hostnames: {
+            async list(params) {
+                return request(withQuery('/api/networking/hostnames', {
+                    projectId: params?.projectId,
+                    status: params?.status
+                }), undefined, R.hostnames_listResponseSchema);
+            },
+            async get(id) {
+                return request(`/api/networking/hostnames/${encodeURIComponent(id)}`, undefined, R.hostnames_getResponseSchema);
+            },
+            async create(input) {
+                return request('/api/networking/hostnames', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.hostnames_createResponseSchema);
+            },
+            async update(id, input) {
+                return request(`/api/networking/hostnames/${encodeURIComponent(id)}`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.hostnames_updateResponseSchema);
+            },
+            async delete(id) {
+                return request(`/api/networking/hostnames/${encodeURIComponent(id)}`, {
+                    method: 'DELETE'
+                }, R.hostnames_deleteResponseSchema);
+            },
+            async verify(id) {
+                return request(`/api/networking/hostnames/${encodeURIComponent(id)}/verify`, {
+                    method: 'POST'
+                }, R.hostnames_verifyResponseSchema);
+            },
+            async listSystem() {
+                return request('/api/networking/hostnames/system', undefined, R.hostnames_listSystemResponseSchema);
+            },
+            async getAccountCertificate(accountSlug) {
+                return request(`/api/networking/hostnames/certificates/${encodeURIComponent(accountSlug)}`, undefined, R.hostnames_getAccountCertificateResponseSchema);
+            }
+        },
+        hosts: {
+            async list(query) {
+                return request(withQuery('/api/hosts', {
+                    status: query?.status,
+                    poolId: query?.poolId,
+                    limit: query?.limit,
+                    offset: query?.offset
+                }), undefined, R.hosts_listResponseSchema);
+            },
+            async get(id) {
+                const result = await request(`/api/hosts/${encodeURIComponent(id)}`, undefined, R.hosts_getResponseSchema);
+                return result.result;
+            },
+            async register(input) {
+                return request('/api/hosts', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.hosts_registerResponseSchema);
+            },
+            async update(id, input) {
+                const result = await request(`/api/hosts/${encodeURIComponent(id)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.hosts_updateResponseSchema);
+                return result.result;
+            },
+            async remove(id) {
+                const result = await request(`/api/hosts/${encodeURIComponent(id)}`, { method: 'DELETE' }, R.hosts_removeResponseSchema);
+                return result?.result ?? result?.host ?? null;
+            },
+            async delete(id) {
+                return this.remove(id);
+            },
+            /**
+             * DELETE /api/hosts/[id], returning the body as the platform sent it so
+             * the caller can report what was torn down. `remove()` keeps its
+             * host-only contract for callers that only retire the record.
+             */
+            async deprovision(id) {
+                return request(`/api/hosts/${encodeURIComponent(id)}`, { method: 'DELETE' }, R.hosts_deprovisionResponseSchema);
+            },
+            /**
+             * Stop compute billing: shut down, snapshot, delete the instance. Answers
+             * after the first step; the platform's pause job finishes it (`phase`).
+             */
+            async pause(id) {
+                return request(`/api/hosts/${encodeURIComponent(id)}/pause`, { method: 'POST' }, R.hosts_pauseResponseSchema);
+            },
+            /** Recreate a paused host from its snapshot; it turns `active` on its next heartbeat. */
+            async resume(id) {
+                return request(`/api/hosts/${encodeURIComponent(id)}/resume`, { method: 'POST' }, R.hosts_pauseResponseSchema);
+            },
+            // enroll, heartbeat, listPoolsForHost, claimAction, updateAction were
+            // DELETED in L6c (platform.md §Migration 1). They are fleet daemon lifecycle
+            // operations, not platform record operations. The fleet daemon client
+            // (L6a/L6d) exposes them; they emit FleetHostEvents platform projects.
+            async listActions(query) {
+                return request(withQuery('/api/hosts/actions', {
+                    status: query?.status,
+                    hostId: query?.hostId,
+                    limit: query?.limit,
+                    offset: query?.offset
+                }), undefined, R.hosts_listActionsResponseSchema);
+            },
+            async createAction(input) {
+                const response = await request('/api/hosts/actions', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.hosts_createActionResponseSchema);
+                return response.result;
+            },
+            async getAction(id) {
+                const response = await request(`/api/hosts/actions/${encodeURIComponent(id)}`, undefined, R.hosts_getActionResponseSchema);
+                return response.result;
+            },
+            /** What the host accepts and who may queue onto or execute on it. */
+            async getActionPolicy(id) {
+                const response = await request(`/api/hosts/${encodeURIComponent(id)}/action-policy`, undefined, R.hosts_getActionPolicyResponseSchema);
+                return response.result;
+            },
+            /** Replace the host's whole action policy; needs host administration. */
+            async setActionPolicy(id, policy) {
+                const response = await request(`/api/hosts/${encodeURIComponent(id)}/action-policy`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(policy)
+                }, R.hosts_setActionPolicyResponseSchema);
+                return response.result;
+            },
+            async provision(input) {
+                return request('/api/hosts/provision', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, provisionHostResponseJsonSchema);
+            }
+        },
+        repositories: {
+            async list(query) {
+                return request(withQuery('/api/repositories', {
+                    ownerType: query?.ownerType,
+                    ownerId: query?.ownerId,
+                    provider: query?.provider,
+                    status: query?.status,
+                    limit: query?.limit,
+                    offset: query?.offset
+                }), undefined, R.repositories_listResponseSchema);
+            },
+            async get(id) {
+                const result = await request(`/api/repositories/${encodeURIComponent(id)}`, undefined, R.repositories_getResponseSchema);
+                return result.result;
+            },
+            async cloneCredential(id) {
+                const result = await request(`/api/repositories/${encodeURIComponent(id)}/clone-credential`, undefined, R.repositories_cloneCredentialResponseSchema);
+                return result.result ?? null;
+            },
+            async create(input) {
+                return request('/api/repositories', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.repositories_createResponseSchema);
+            },
+            async update(id, input) {
+                return request(`/api/repositories/${encodeURIComponent(id)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.repositories_updateResponseSchema);
+            },
+            async remove(id) {
+                await request(`/api/repositories/${encodeURIComponent(id)}`, {
+                    method: 'DELETE'
+                }, R.repositories_removeResponseSchema);
+            }
+        },
+        // codeSessions removed — use @vibesdotdev/code-sessions' createSsrCodeSessionsClient
+        // (SSR / SvelteKit +server.ts) or the runtime-resolved CodeSessionsClient
+        // (browser / CLI). See code-sessions for the canonical surface.
+        daemons: {
+            async list(query) {
+                return request(withQuery('/api/daemons', {
+                    hostId: query?.hostId,
+                    kind: query?.kind,
+                    capability: query?.capability,
+                    status: query?.status,
+                    limit: query?.limit,
+                    offset: query?.offset
+                }), undefined, R.daemons_listResponseSchema);
+            },
+            async get(id) {
+                const result = await request(`/api/daemons/${encodeURIComponent(id)}`, undefined, R.daemons_getResponseSchema);
+                return result.result;
+            },
+            async register(input) {
+                const result = await request('/api/daemons', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.daemons_registerResponseSchema);
+                return result.result;
+            },
+            async update(id, input) {
+                const result = await request(`/api/daemons/${encodeURIComponent(id)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.daemons_updateResponseSchema);
+                return result.result;
+            },
+            async retire(id) {
+                await request(`/api/daemons/${encodeURIComponent(id)}`, {
+                    method: 'DELETE'
+                }, R.daemons_retireResponseSchema);
+            }
+        },
+        processes: {
+            async list(query) {
+                return request(withQuery('/api/processes', {
+                    hostId: query?.hostId,
+                    spawnedByDaemonId: query?.spawnedByDaemonId,
+                    kind: query?.kind,
+                    status: query?.status,
+                    activeOnly: query?.activeOnly,
+                    limit: query?.limit,
+                    offset: query?.offset
+                }), undefined, R.processes_listResponseSchema);
+            },
+            async get(id) {
+                const result = await request(`/api/processes/${encodeURIComponent(id)}`, undefined, R.processes_getResponseSchema);
+                return result.result;
+            },
+            async register(input) {
+                const result = await request('/api/processes', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.processes_registerResponseSchema);
+                return result.result;
+            },
+            async update(id, input) {
+                const result = await request(`/api/processes/${encodeURIComponent(id)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.processes_updateResponseSchema);
+                return result.result;
+            },
+            async stop(id) {
+                const result = await request(`/api/processes/${encodeURIComponent(id)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ status: 'stopping' })
+                }, R.processes_stopResponseSchema);
+                return result.result;
+            }
+        },
+        scheduledTasks: {
+            /** Host enrollment authenticates this call; persisted task authority supplies Chat identity. */
+            dispatchFromHost(hostId, taskId, input) {
+                return request(`/api/internal/hosts/${encodeURIComponent(hostId)}/scheduled-tasks/${encodeURIComponent(taskId)}/dispatch`, {
+                    method: 'POST', credentials: 'omit', body: JSON.stringify(input)
+                }, R.scheduledTasks_dispatchFromHostResponseSchema);
+            },
+            async list(query) {
+                return request(withQuery('/api/scheduled-tasks', {
+                    ownerType: query?.ownerType,
+                    hostId: query?.hostId,
+                    bindingKind: query?.bindingKind,
+                    enabled: query?.enabled,
+                    limit: query?.limit,
+                    cursor: query?.cursor
+                }), undefined, R.scheduledTasks_listResponseSchema);
+            },
+            async get(id) {
+                const result = await request(`/api/scheduled-tasks/${encodeURIComponent(id)}`, undefined, R.scheduledTasks_getResponseSchema);
+                return result.result;
+            },
+            async create(input) {
+                const result = await request('/api/scheduled-tasks', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.scheduledTasks_createResponseSchema);
+                return result.result;
+            },
+            async update(id, input) {
+                const result = await request(`/api/scheduled-tasks/${encodeURIComponent(id)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.scheduledTasks_updateResponseSchema);
+                return result.result;
+            },
+            async delete(id) {
+                await request(`/api/scheduled-tasks/${encodeURIComponent(id)}`, {
+                    method: 'DELETE'
+                }, R.scheduledTasks_deleteResponseSchema);
+            },
+            async trigger(id) {
+                return request(`/api/scheduled-tasks/${encodeURIComponent(id)}/trigger`, {
+                    method: 'POST'
+                }, R.scheduledTasks_triggerResponseSchema);
+            }
+        },
+        infrastructure: {
+            async summary() {
+                return request('/api/infrastructure/summary', undefined, R.infrastructure_summaryResponseSchema);
+            },
+            async health() {
+                return request('/api/infrastructure/health', undefined, R.infrastructure_healthResponseSchema);
+            },
+            async usage() {
+                return request('/api/infrastructure/usage', undefined, R.infrastructure_usageResponseSchema);
+            }
+        },
+        components: {
+            async list(query) {
+                return request(withQuery('/api/components', {
+                    visibility: query?.visibility,
+                    slug: query?.slug,
+                    limit: query?.limit,
+                    offset: query?.offset
+                }), undefined, R.components_listResponseSchema);
+            },
+            async get(id) {
+                const result = await request(`/api/components/${encodeURIComponent(id)}`, undefined, R.components_getResponseSchema);
+                return result.result;
+            },
+            async create(input) {
+                const result = await request('/api/components', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.components_createResponseSchema);
+                return result.result;
+            },
+            async update(id, input) {
+                const result = await request(`/api/components/${encodeURIComponent(id)}`, {
+                    method: 'PATCH',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.components_updateResponseSchema);
+                return result.result;
+            },
+            async delete(id) {
+                await request(`/api/components/${encodeURIComponent(id)}`, {
+                    method: 'DELETE'
+                }, R.components_deleteResponseSchema);
+            },
+            async publish(id, input = {}) {
+                return request(`/api/components/${encodeURIComponent(id)}/publish`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(input)
+                }, R.components_publishResponseSchema);
+            },
+            async listVersions(id) {
+                return request(`/api/components/${encodeURIComponent(id)}/versions`, undefined, R.components_listVersionsResponseSchema);
+            },
+            /**
+             * Resolve ONE release the caller already knows the digest of.
+             *
+             * Distinct from `listVersions`, which is owner-only because enumerating
+             * another author's releases is enumeration. Here the digest IS the
+             * authorization: holding a sha256 of bytes means a document that pins
+             * them told you. Returns null for an absent release; transport and admission failures
+             * remain observable by the embedding surface.
+             */
+            async resolveRelease(id, version, bundleHash) {
+                const path = `/api/components/${encodeURIComponent(id)}/versions/${encodeURIComponent(version)}/resolve?bundleHash=${encodeURIComponent(bundleHash)}`;
+                const response = await settle(() => request(path, undefined, R.components_resolveReleaseResponseSchema));
+                if (response.ok)
+                    return response.value.result ?? null;
+                if (response.cause instanceof PlatformApiError && response.cause.status === 404 && response.cause.path === path)
+                    return null;
+                throw response.cause;
+            },
+            bundleUrl(id, version) {
+                return `${options.origin}/components/${encodeURIComponent(id)}/${encodeURIComponent(version)}.js`;
+            },
+            manifestUrl(id) {
+                return `${options.origin}/components/${encodeURIComponent(id)}/manifest.json`;
+            }
+        }
+    };
+}
+//# sourceMappingURL=http.js.map