@openchamber/sdk 1.23.2-preview.1

package/dist/host.js

@@ -0,0 +1,606 @@
+import { OPENCHAMBER_SDK_API_VERSION, OPENCHAMBER_SDK_CHANNEL } from "./api-version.js";
+import { GUEST_STORAGE_KEY_MAX, GUEST_STORAGE_VALUE_BYTES } from "./workspace.js";
+import { GUEST_FILE_CONTENT_MAX, GUEST_FILE_PATH_MAX, GUEST_GENERATE_OUTPUT_TOKENS_MAX, GUEST_GENERATE_PROMPT_MAX, GUEST_GENERATE_SYSTEM_MAX, GUEST_GENERATE_TIMEOUT_MS, GUEST_REQUEST_TIMEOUT_MS, GUEST_RESOLVE_ERROR_MAX, isGuestFilePath, isGuestRequestPath, clampAttachRequest, clampBadgeCount, clampPromptRequest, clampStartSessionRequest, readHostMessage, isGenerateResult, isFileListResult, isFileReadResult, isFileStatResult, isJsonValue, isFileWriteResult, isServiceStatusResult, isGuestRequestResult, isPromptResult, isStartSessionResult, } from "./contract.js";
+export class HostRequestError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'HostRequestError';
+        this.code = code;
+    }
+}
+// The host drops a message its schema rejects without answering, so a bad
+// path would otherwise surface only as HOST_TIMEOUT twenty seconds later.
+const rejectBadPath = () => Promise.reject(new HostRequestError('BAD_PATH', 'Request path must start with "/" and stay on the declared origin.'));
+const rejectBadFilePath = () => Promise.reject(new HostRequestError('BAD_PATH', `File path must be 1 to ${GUEST_FILE_PATH_MAX} characters without NUL or backslash.`));
+const nextId = (n) => {
+    n.value += 1;
+    return `oc-${n.value}`;
+};
+export const connectHost = (options = {}) => {
+    const target = options.target ?? ('window' in globalThis ? window : null);
+    if (!target) {
+        throw new HostRequestError('HOST_UNAVAILABLE', 'No window. connectHost runs in a browser frame.');
+    }
+    const acceptSource = options.acceptSource ?? ((source) => source === target.parent);
+    const requestTimeoutMs = options.requestTimeoutMs ?? GUEST_REQUEST_TIMEOUT_MS;
+    const readyListeners = new Set();
+    const directoryListeners = new Set();
+    const sessionListeners = new Set();
+    const lifecycleListeners = new Set();
+    const connectionListeners = new Set();
+    const settingsListeners = new Set();
+    const itemListeners = new Set();
+    let resolveHandler = null;
+    const pending = new Map();
+    const workspaceListeners = new Map();
+    let disposed = false;
+    const ids = { value: 0 };
+    let lastReady = null;
+    let lastLifecycle = null;
+    const lifecycleFromSession = (session) => {
+        if (!session)
+            return null;
+        return {
+            sessionId: session.id,
+            phase: session.busy ? 'started' : 'completed',
+        };
+    };
+    const post = (message) => {
+        target.parent.postMessage(message, '*');
+    };
+    // One listener that throws must not starve the ones after it; the error
+    // surfaces on the console the way an event handler's would.
+    const emit = (listeners, value) => {
+        for (const listener of listeners) {
+            try {
+                listener(value);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
+    };
+    const onMessage = (event) => {
+        if (!(event instanceof MessageEvent))
+            return;
+        if (!acceptSource(event.source))
+            return;
+        const message = readHostMessage(event.data);
+        if (!message)
+            return;
+        if (message.type === 'workspace') {
+            const listener = workspaceListeners.get(message.payload.subscriptionId);
+            if (listener)
+                emit([listener], message.payload.snapshot);
+            return;
+        }
+        if (message.type === 'ready') {
+            lastReady = message.payload;
+            lastLifecycle = lifecycleFromSession(message.payload.session);
+            emit(readyListeners, message.payload);
+            emit(directoryListeners, message.payload.directory);
+            emit(sessionListeners, message.payload.session);
+            if (lastLifecycle) {
+                emit(lifecycleListeners, lastLifecycle);
+            }
+            emit(connectionListeners, message.payload.connection);
+            emit(settingsListeners, message.payload.settings);
+            emit(itemListeners, message.payload.item);
+            return;
+        }
+        if (message.type === 'directory') {
+            if (lastReady) {
+                lastReady = { ...lastReady, directory: message.payload.directory };
+            }
+            emit(directoryListeners, message.payload.directory);
+            return;
+        }
+        if (message.type === 'session') {
+            if (lastReady) {
+                lastReady = { ...lastReady, session: message.payload.session };
+            }
+            if (!message.payload.session) {
+                lastLifecycle = null;
+            }
+            else if (lastLifecycle?.sessionId !== message.payload.session.id) {
+                lastLifecycle = lifecycleFromSession(message.payload.session);
+            }
+            emit(sessionListeners, message.payload.session);
+            return;
+        }
+        if (message.type === 'session-lifecycle') {
+            lastLifecycle = message.payload;
+            emit(lifecycleListeners, message.payload);
+            return;
+        }
+        if (message.type === 'connection') {
+            if (lastReady) {
+                lastReady = { ...lastReady, connection: message.payload.connection };
+            }
+            emit(connectionListeners, message.payload.connection);
+            return;
+        }
+        if (message.type === 'settings') {
+            if (lastReady) {
+                lastReady = { ...lastReady, settings: message.payload.settings };
+            }
+            emit(settingsListeners, message.payload.settings);
+            return;
+        }
+        if (message.type === 'item') {
+            if (lastReady) {
+                lastReady = { ...lastReady, item: message.payload.item };
+            }
+            emit(itemListeners, message.payload.item);
+            return;
+        }
+        if (message.type === 'resolve') {
+            const answer = (payload) => {
+                post({
+                    channel: OPENCHAMBER_SDK_CHANNEL,
+                    v: OPENCHAMBER_SDK_API_VERSION,
+                    type: 'resolve-result',
+                    id: message.id,
+                    payload,
+                });
+            };
+            const handler = resolveHandler;
+            if (!handler) {
+                answer({ error: 'This extension does not resolve commands.' });
+                return;
+            }
+            Promise.resolve()
+                .then(() => handler(message.payload))
+                .then((item) => answer({ item: item ? clampAttachRequest(item) : null }), (error) => {
+                const text = (error instanceof Error ? error.message : String(error)).trim();
+                answer({ error: (text || 'Command failed.').slice(0, GUEST_RESOLVE_ERROR_MAX) });
+            });
+            return;
+        }
+        const waiter = pending.get(message.id);
+        if (!waiter)
+            return;
+        clearTimeout(waiter.timer);
+        pending.delete(message.id);
+        if (message.ok) {
+            waiter.resolve(message.payload);
+            return;
+        }
+        waiter.reject(new HostRequestError(message.code, message.error));
+    };
+    target.addEventListener('message', onMessage);
+    post({
+        channel: OPENCHAMBER_SDK_CHANNEL,
+        v: OPENCHAMBER_SDK_API_VERSION,
+        type: 'hello',
+    });
+    const send = (message, timeoutMs = requestTimeoutMs) => {
+        if (disposed || target.parent === target) {
+            return Promise.reject(new HostRequestError('HOST_UNAVAILABLE', 'No host frame. This page is not in an iframe.'));
+        }
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                pending.delete(message.id);
+                reject(new HostRequestError('HOST_TIMEOUT', 'Host did not answer in time.'));
+            }, timeoutMs);
+            pending.set(message.id, { resolve, reject, timer });
+            post(message);
+        });
+    };
+    const request = (message) => (send(message).then(() => undefined));
+    const envelope = { channel: OPENCHAMBER_SDK_CHANNEL, v: OPENCHAMBER_SDK_API_VERSION };
+    const requireIdentity = (value, maximum = 1024) => {
+        if (!value.trim() || value.length > maximum)
+            throw new HostRequestError('HOST_REJECTED', `Identity must contain 1 to ${maximum} characters.`);
+    };
+    const readWorkspace = async (query) => {
+        if (query.kind !== 'projects')
+            requireIdentity(query.projectId);
+        const result = await send({ ...envelope, type: 'workspace-read', id: nextId(ids), payload: query });
+        if (!result || !('kind' in result) || !('state' in result) || result.kind !== query.kind) {
+            throw new HostRequestError('HOST_REJECTED', 'Host did not return workspace data.');
+        }
+        return result;
+    };
+    const subscribeWorkspace = async (query, listener) => {
+        if (query.kind !== 'projects')
+            requireIdentity(query.projectId);
+        const subscriptionId = nextId(ids);
+        workspaceListeners.set(subscriptionId, listener);
+        try {
+            await request({ ...envelope, type: 'workspace-subscribe', id: nextId(ids), payload: { subscriptionId, query } });
+        }
+        catch (error) {
+            workspaceListeners.delete(subscriptionId);
+            if (!disposed)
+                post({ ...envelope, type: 'workspace-unsubscribe', id: nextId(ids), payload: { subscriptionId } });
+            throw error;
+        }
+        return () => {
+            if (!workspaceListeners.delete(subscriptionId) || disposed)
+                return;
+            post({ ...envelope, type: 'workspace-unsubscribe', id: nextId(ids), payload: { subscriptionId } });
+        };
+    };
+    const storage = async (payload) => {
+        if ('key' in payload && (payload.key.length === 0 || payload.key.length > GUEST_STORAGE_KEY_MAX)) {
+            throw new HostRequestError('HOST_REJECTED', 'Storage key must contain 1 to 128 characters.');
+        }
+        if (payload.op === 'set' && !isJsonValue(payload.value)) {
+            throw new HostRequestError('HOST_REJECTED', 'Storage values must be JSON.');
+        }
+        if (payload.op === 'set' && new TextEncoder().encode(JSON.stringify(payload.value)).length > GUEST_STORAGE_VALUE_BYTES) {
+            throw new HostRequestError('HOST_REJECTED', 'Storage value exceeds 64 KiB.');
+        }
+        const result = await send({ ...envelope, type: 'storage', id: nextId(ids), payload });
+        if (!result || !('storage' in result) || result.op !== payload.op)
+            throw new HostRequestError('HOST_REJECTED', 'Host did not return storage data.');
+        return result;
+    };
+    return {
+        listProjects: async () => {
+            const result = await readWorkspace({ kind: 'projects' });
+            if (result.kind !== 'projects')
+                throw new HostRequestError('HOST_REJECTED', 'Expected projects.');
+            return result;
+        },
+        listWorktrees: async (projectId) => {
+            const result = await readWorkspace({ kind: 'worktrees', projectId });
+            if (result.kind !== 'worktrees')
+                throw new HostRequestError('HOST_REJECTED', 'Expected worktrees.');
+            return result;
+        },
+        listSessions: async (projectId) => {
+            const result = await readWorkspace({ kind: 'sessions', projectId });
+            if (result.kind !== 'sessions')
+                throw new HostRequestError('HOST_REJECTED', 'Expected sessions.');
+            return result;
+        },
+        onProjects: (listener) => subscribeWorkspace({ kind: 'projects' }, (snapshot) => { if (snapshot.kind === 'projects')
+            listener(snapshot); }),
+        onWorktrees: (projectId, listener) => subscribeWorkspace({ kind: 'worktrees', projectId }, (snapshot) => { if (snapshot.kind === 'worktrees')
+            listener(snapshot); }),
+        onSessions: (projectId, listener) => subscribeWorkspace({ kind: 'sessions', projectId }, (snapshot) => { if (snapshot.kind === 'sessions')
+            listener(snapshot); }),
+        openSession: async (sessionId) => {
+            requireIdentity(sessionId);
+            await request({ ...envelope, type: 'open-session', id: nextId(ids), payload: { sessionId } });
+        },
+        storage: {
+            get: async (key) => {
+                const result = await storage({ op: 'get', key });
+                return result.op === 'get' && result.found ? result.value : undefined;
+            },
+            set: async (key, value) => { await storage({ op: 'set', key, value }); },
+            delete: async (key) => { await storage({ op: 'delete', key }); },
+            keys: async () => {
+                const result = await storage({ op: 'keys' });
+                if (result.op !== 'keys')
+                    throw new HostRequestError('HOST_REJECTED', 'Expected storage keys.');
+                return result.keys;
+            },
+        },
+        onReady: (listener) => {
+            readyListeners.add(listener);
+            if (lastReady)
+                listener(lastReady);
+            return () => {
+                readyListeners.delete(listener);
+            };
+        },
+        onDirectory: (listener) => {
+            directoryListeners.add(listener);
+            if (lastReady)
+                listener(lastReady.directory);
+            return () => {
+                directoryListeners.delete(listener);
+            };
+        },
+        onSession: (listener) => {
+            sessionListeners.add(listener);
+            if (lastReady)
+                listener(lastReady.session);
+            return () => {
+                sessionListeners.delete(listener);
+            };
+        },
+        onSessionLifecycle: (listener) => {
+            lifecycleListeners.add(listener);
+            if (lastLifecycle)
+                listener(lastLifecycle);
+            return () => {
+                lifecycleListeners.delete(listener);
+            };
+        },
+        onConnection: (listener) => {
+            connectionListeners.add(listener);
+            if (lastReady)
+                listener(lastReady.connection);
+            return () => {
+                connectionListeners.delete(listener);
+            };
+        },
+        onSettings: (listener) => {
+            settingsListeners.add(listener);
+            if (lastReady)
+                listener(lastReady.settings);
+            return () => {
+                settingsListeners.delete(listener);
+            };
+        },
+        onItem: (listener) => {
+            itemListeners.add(listener);
+            if (lastReady)
+                listener(lastReady.item);
+            return () => {
+                itemListeners.delete(listener);
+            };
+        },
+        onResolve: (handler) => {
+            resolveHandler = handler;
+            return () => {
+                if (resolveHandler === handler)
+                    resolveHandler = null;
+            };
+        },
+        toast: (payload) => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'toast',
+            id: nextId(ids),
+            payload,
+        }),
+        openUrl: (url) => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'open-url',
+            id: nextId(ids),
+            payload: { url },
+        }),
+        openSurface: (surfaceId) => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'open-surface',
+            id: nextId(ids),
+            payload: { surfaceId },
+        }),
+        writeClipboard: (text) => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'clipboard-write',
+            id: nextId(ids),
+            payload: { text },
+        }),
+        compose: (payload) => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'compose',
+            id: nextId(ids),
+            payload,
+        }),
+        attach: (payload) => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'attach',
+            id: nextId(ids),
+            payload: clampAttachRequest(payload),
+        }),
+        startSession: async (payload) => {
+            if (payload.projectId !== undefined)
+                requireIdentity(payload.projectId);
+            const worktree = payload.worktree;
+            if (worktree && worktree !== true) {
+                if (worktree.kind === 'existing')
+                    requireIdentity(worktree.directory);
+                else {
+                    if (worktree.name !== undefined)
+                        requireIdentity(worktree.name, 200);
+                    if (worktree.baseBranch !== undefined)
+                        requireIdentity(worktree.baseBranch, 200);
+                }
+            }
+            const result = await send({
+                channel: OPENCHAMBER_SDK_CHANNEL,
+                v: OPENCHAMBER_SDK_API_VERSION,
+                type: 'start-session',
+                id: nextId(ids),
+                payload: clampStartSessionRequest(payload),
+            }, options.requestTimeoutMs ?? 180_000);
+            if (!isStartSessionResult(result)) {
+                throw new HostRequestError('HOST_REJECTED', 'Host did not return a session.');
+            }
+            return result;
+        },
+        prompt: (payload) => send({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'prompt',
+            id: nextId(ids),
+            payload: clampPromptRequest(payload),
+        }).then((result) => {
+            if (!isPromptResult(result)) {
+                throw new HostRequestError('HOST_REJECTED', 'Host did not return a prompt result.');
+            }
+            return result;
+        }),
+        sessionLink: (payload) => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'session-link',
+            id: nextId(ids),
+            payload: clampAttachRequest(payload),
+        }),
+        close: () => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'close',
+            id: nextId(ids),
+        }),
+        oauthStart: () => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'oauth-start',
+            id: nextId(ids),
+        }),
+        oauthDisconnect: () => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'oauth-disconnect',
+            id: nextId(ids),
+        }),
+        request: (payload) => (isGuestRequestPath(payload.path) ? send({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'request',
+            id: nextId(ids),
+            payload,
+        }) : rejectBadPath()).then((result) => {
+            if (!isGuestRequestResult(result)) {
+                throw new HostRequestError('HOST_REJECTED', 'Host request result was empty.');
+            }
+            return result;
+        }),
+        serviceRequest: (payload) => (isGuestRequestPath(payload.path) ? send({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'service-request',
+            id: nextId(ids),
+            payload,
+        }) : rejectBadPath()).then((result) => {
+            if (!isGuestRequestResult(result)) {
+                throw new HostRequestError('HOST_REJECTED', 'Host service request result was empty.');
+            }
+            return result;
+        }),
+        serviceStatus: () => send({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'service-status',
+            id: nextId(ids),
+        }).then((result) => {
+            if (!isServiceStatusResult(result)) {
+                throw new HostRequestError('HOST_REJECTED', 'Host did not return service status.');
+            }
+            return result;
+        }),
+        readFile: (path) => (isGuestFilePath(path) ? send({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'file-read',
+            id: nextId(ids),
+            payload: { path },
+        }) : rejectBadFilePath()).then((result) => {
+            if (!isFileReadResult(result)) {
+                throw new HostRequestError('HOST_REJECTED', 'Host did not return file content.');
+            }
+            return result;
+        }),
+        writeFile: (path, content) => {
+            if (!isGuestFilePath(path)) {
+                return rejectBadFilePath();
+            }
+            if (content.length > GUEST_FILE_CONTENT_MAX) {
+                return Promise.reject(new HostRequestError('FILE_TOO_LARGE', `Content is over ${GUEST_FILE_CONTENT_MAX} characters.`));
+            }
+            return send({
+                channel: OPENCHAMBER_SDK_CHANNEL,
+                v: OPENCHAMBER_SDK_API_VERSION,
+                type: 'file-write',
+                id: nextId(ids),
+                payload: { path, content },
+            }).then((result) => {
+                if (!isFileWriteResult(result)) {
+                    throw new HostRequestError('HOST_REJECTED', 'Host did not confirm the write.');
+                }
+                return result;
+            });
+        },
+        listDir: (path) => (isGuestFilePath(path) ? send({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'file-list',
+            id: nextId(ids),
+            payload: { path },
+        }) : rejectBadFilePath()).then((result) => {
+            if (!isFileListResult(result)) {
+                throw new HostRequestError('HOST_REJECTED', 'Host did not return directory entries.');
+            }
+            return result;
+        }),
+        stat: (path) => (isGuestFilePath(path) ? send({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'file-stat',
+            id: nextId(ids),
+            payload: { path },
+        }) : rejectBadFilePath()).then((result) => {
+            if (!isFileStatResult(result)) {
+                throw new HostRequestError('HOST_REJECTED', 'Host did not return file status.');
+            }
+            return result;
+        }),
+        generate: (input) => {
+            const prompt = input.prompt.trim();
+            const system = input.system?.trim();
+            if (prompt.length === 0 || prompt.length > GUEST_GENERATE_PROMPT_MAX) {
+                return Promise.reject(new HostRequestError('HOST_REJECTED', `Prompt must be 1 to ${GUEST_GENERATE_PROMPT_MAX} characters.`));
+            }
+            if (system !== undefined && (system.length === 0 || system.length > GUEST_GENERATE_SYSTEM_MAX)) {
+                return Promise.reject(new HostRequestError('HOST_REJECTED', `System prompt must be 1 to ${GUEST_GENERATE_SYSTEM_MAX} characters.`));
+            }
+            const maxOutputTokens = input.maxOutputTokens === undefined
+                ? undefined
+                : Math.min(GUEST_GENERATE_OUTPUT_TOKENS_MAX, Math.max(1, Math.floor(input.maxOutputTokens)));
+            if (maxOutputTokens !== undefined && !Number.isFinite(maxOutputTokens)) {
+                return Promise.reject(new HostRequestError('HOST_REJECTED', 'maxOutputTokens must be a number.'));
+            }
+            const payload = { prompt };
+            if (system !== undefined)
+                payload.system = system;
+            if (maxOutputTokens !== undefined)
+                payload.maxOutputTokens = maxOutputTokens;
+            // The model answers slower than any other host call, so this one waits longer.
+            return send({
+                channel: OPENCHAMBER_SDK_CHANNEL,
+                v: OPENCHAMBER_SDK_API_VERSION,
+                type: 'generate',
+                id: nextId(ids),
+                payload,
+            }, options.requestTimeoutMs ?? GUEST_GENERATE_TIMEOUT_MS).then((result) => {
+                if (!isGenerateResult(result)) {
+                    throw new HostRequestError('HOST_REJECTED', 'Host did not return generated text.');
+                }
+                return result;
+            });
+        },
+        setBadge: (count) => request({
+            channel: OPENCHAMBER_SDK_CHANNEL,
+            v: OPENCHAMBER_SDK_API_VERSION,
+            type: 'badge',
+            id: nextId(ids),
+            payload: { count: clampBadgeCount(count) },
+        }),
+        dispose: () => {
+            for (const subscriptionId of workspaceListeners.keys()) {
+                post({ ...envelope, type: 'workspace-unsubscribe', id: nextId(ids), payload: { subscriptionId } });
+            }
+            workspaceListeners.clear();
+            disposed = true;
+            resolveHandler = null;
+            target.removeEventListener('message', onMessage);
+            for (const waiter of pending.values()) {
+                clearTimeout(waiter.timer);
+                waiter.reject(new HostRequestError('HOST_UNAVAILABLE', 'Host client was disposed.'));
+            }
+            pending.clear();
+            readyListeners.clear();
+            directoryListeners.clear();
+            sessionListeners.clear();
+            lifecycleListeners.clear();
+            connectionListeners.clear();
+            settingsListeners.clear();
+            itemListeners.clear();
+        },
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { OPENCHAMBER_SDK_API_VERSION, OPENCHAMBER_SDK_CHANNEL, OPENCHAMBER_SDK_MANIFEST_API_VERSIONS } from './api-version.ts';
+export type { GuestLoadState, GuestProject, GuestWorktree, GuestSessionActivity, GuestSessionRecord, GuestDirectoryCoverage, GuestProjectsSnapshot, GuestWorktreesSnapshot, GuestSessionsSnapshot, GuestWorkspaceSnapshot, GuestWorkspaceQuery, GuestWorkspaceSubscription, GuestWorkspaceUpdate, GuestStorageRequest, GuestStorageResult, GuestSessionWorktree } from './workspace.ts';
+export { GUEST_STORAGE_KEY_MAX, GUEST_STORAGE_KEYS_MAX, GUEST_STORAGE_VALUE_BYTES, GUEST_STORAGE_TOTAL_BYTES } from './workspace.ts';
+export type { OpenChamberManifestApiVersion } from './api-version.ts';
+export { compareOpenChamberVersions, hostMeetsOpenChamberEngine, openChamberEngineMinimum, OPENCHAMBER_ENGINE_PATTERN, parseOpenChamberVersion, } from './host-version.ts';
+export { DECLARED_GUEST_CAPABILITIES, GUEST_ACTIONS_MAX, GUEST_ACTION_LABEL_MAX, GUEST_CAPABILITIES, GUEST_COMMANDS_MAX, GUEST_COMMAND_DESCRIPTION_MAX, GUEST_COMMAND_NAME, GUEST_TOOLS_MAX, GUEST_TOOL_COLUMNS_MAX, GUEST_TOOL_COLUMN_MAX, GUEST_TOOL_LANGUAGE_MAX, GUEST_TOOL_MATCH, GUEST_TOOL_MATCH_MAX, GUEST_TOOL_NAME_MAX, GUEST_TOOL_OUTPUTS, GUEST_TOOL_TEMPLATE_MAX, GUEST_TOOL_TEMPLATE_VALUE_MAX, guestActionsNeedConversation, GUEST_FILESYSTEM_PATTERN_MAX, GUEST_FILESYSTEM_PATTERNS_MAX, HOST_LINEAR_API_ORIGIN, isGuestFilesystemPattern, hasGuestCapability, hasGuestPage, isGuestApproved, isGuestPackageSvgIcon, requestedGuestCapabilities, resolveAttachEntry, resolvePageEntry, resolveAttachMode, resolveIntegrationApi, resolveIntegrationAuth, toPublicService, toPublicIntegration, } from './manifest.ts';
+export type { ServiceContribution, ServicePermissions, GuestActionContribution, GuestActionPayload, GuestActionRole, GuestActionWhere, GuestCommandContribution, GuestToolContribution, GuestToolOutput, AttachContribution, AttachContributionObject, AttachMode, DeclaredGuestCapability, GuestAuthorization, GuestCapability, IntegrationAuth, IntegrationContribution, IntegrationHost, IntegrationHostProvider, IntegrationOAuth, IntegrationOAuthAccount, IntegrationSettingField, IntegrationToken, IntegrationTokenScheme, OpenChamberContributes, OpenChamberEngines, OpenChamberManifest, PanelContribution, PageContribution, ParseManifestErrorCode, ParseManifestFailure, ParseManifestResult, ParseManifestSuccess, PublicService, PublicServicePermissions, PublicGuestCapabilities, PublicIntegration, PublicIntegrationToken, PublicSocketBinding, ResolvedGuestApi, SocketBinding, SocketPlatform, } from './manifest.ts';
+export { connectHost, HostRequestError } from './host.ts';
+export type { HostClient, HostClientOptions, HostFrame } from './host.ts';
+export { clampAttachRequest, clampBadgeCount, clampPromptRequest, clampStartSessionRequest, guestFileScope, isAttachData, isJsonValue, isFileListResult, isFileReadResult, isFileStatResult, isGenerateResult, isFileWriteResult, isGuestFilePath, isGuestAttachItem, isGuestMessageItem, isGuestSessionItem, isServiceStatusResult, isGuestRequestPath, isGuestRequestResult, isHostRequestErrorCode, isPromptResult, isStartSessionResult, readHostMessage, resolveHostRequestErrorCode, } from './contract.ts';
+export type { BadgeRequest, GuestBadgeMessage, GuestItem, GuestItemRole, GuestMessageItem, GuestResolveResultMessage, GuestSessionItem, GuestSessionItemMessage, HostResolveMessage, ResolveRequest, ResolveResultPayload, FileListEntry, FileListRequest, FileListResult, FileReadRequest, FileReadResult, FileStatRequest, FileStatResult, FileWriteRequest, FileWriteResult, GenerateRequest, GenerateResult, GuestFileEntryKind, GuestFileListMessage, GuestFileReadMessage, GuestFileScope, GuestFileStatKind, GuestFileStatMessage, GuestGenerateMessage, GuestFileWriteMessage, ServiceStatus, ServiceStatusResult, HostRequestErrorCode, AttachBranches, AttachIssueRequest, AttachThreadKind, JsonValue, HostResultPayload, PromptRequest, PromptResult, SessionLifecycleEvent, SessionLifecyclePhase, StartSessionRequest, StartSessionResult, StartSessionSent, ComposeRequest, GuestServiceRequestMessage, GuestServiceStatusMessage, GuestAttachMessage, GuestClipboardWriteMessage, GuestCloseMessage, GuestComposeMessage, GuestConnection, GuestHelloMessage, GuestMessage, GuestOauthDisconnectMessage, GuestOauthStartMessage, GuestOpenSurfaceMessage, GuestOpenUrlMessage, GuestRequest, GuestRequestMessage, GuestRequestMethod, GuestPromptMessage, GuestSessionLinkMessage, GuestStartSessionMessage, GuestRequestResult, GuestSettings, GuestToastMessage, GuestHostSurface, HostConnectionMessage, HostDirectoryMessage, HostItemMessage, HostMessage, HostReadyContext, HostReadyMessage, HostResultMessage, HostSessionLifecycleMessage, HostSessionMessage, HostSettingsMessage, HostTheme, HostThemeMode, HostThemeTokens, SessionSnapshot, ToastKind, ToastRequest, } from './contract.ts';
+export { EMPTY_GUEST_CONNECTION, GUEST_BADGE_MAX, GUEST_ITEM_MESSAGE_TEXT_MAX, GUEST_ITEM_SESSION_MAX, GUEST_RESOLVE_ERROR_MAX, GUEST_FILE_CONTENT_MAX, GUEST_FILE_ENTRY_KINDS, GUEST_FILE_LIST_MAX, GUEST_FILE_PATH_MAX, GUEST_GENERATE_OUTPUT_TOKENS_MAX, GUEST_GENERATE_PROMPT_MAX, GUEST_GENERATE_SYSTEM_MAX, GUEST_GENERATE_TEXT_MAX, GUEST_GENERATE_TIMEOUT_MS, GUEST_FILE_STAT_KINDS, SERVICE_STATUS_VALUES, HOST_REQUEST_ERROR_CODES, SESSION_LIFECYCLE_PHASES, START_SESSION_SENT, GUEST_ACCOUNT_MAX, GUEST_SESSION_AGENT_MAX, GUEST_SESSION_MODEL_MAX, GUEST_ATTACH_AUTHOR_MAX, GUEST_ATTACH_BRANCH_MAX, GUEST_ATTACH_DATA_MAX, GUEST_ATTACH_ID_MAX, GUEST_ATTACH_TEXT_MAX, GUEST_ATTACH_TITLE_MAX, GUEST_ATTACH_URL_MAX, GUEST_CLIPBOARD_TEXT_MAX, GUEST_TOAST_MAX, GUEST_COMPOSE_TEXT_MAX, GUEST_REQUEST_BODY_MAX, GUEST_REQUEST_PATH_MAX, GUEST_REQUEST_RESPONSE_MAX, GUEST_REQUEST_TIMEOUT_MS, GUEST_SETTING_VALUE_MAX, } from './contract.ts';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { OPENCHAMBER_SDK_API_VERSION, OPENCHAMBER_SDK_CHANNEL, OPENCHAMBER_SDK_MANIFEST_API_VERSIONS } from "./api-version.js";
+export { GUEST_STORAGE_KEY_MAX, GUEST_STORAGE_KEYS_MAX, GUEST_STORAGE_VALUE_BYTES, GUEST_STORAGE_TOTAL_BYTES } from "./workspace.js";
+export { compareOpenChamberVersions, hostMeetsOpenChamberEngine, openChamberEngineMinimum, OPENCHAMBER_ENGINE_PATTERN, parseOpenChamberVersion, } from "./host-version.js";
+export { DECLARED_GUEST_CAPABILITIES, GUEST_ACTIONS_MAX, GUEST_ACTION_LABEL_MAX, GUEST_CAPABILITIES, GUEST_COMMANDS_MAX, GUEST_COMMAND_DESCRIPTION_MAX, GUEST_COMMAND_NAME, GUEST_TOOLS_MAX, GUEST_TOOL_COLUMNS_MAX, GUEST_TOOL_COLUMN_MAX, GUEST_TOOL_LANGUAGE_MAX, GUEST_TOOL_MATCH, GUEST_TOOL_MATCH_MAX, GUEST_TOOL_NAME_MAX, GUEST_TOOL_OUTPUTS, GUEST_TOOL_TEMPLATE_MAX, GUEST_TOOL_TEMPLATE_VALUE_MAX, guestActionsNeedConversation, GUEST_FILESYSTEM_PATTERN_MAX, GUEST_FILESYSTEM_PATTERNS_MAX, HOST_LINEAR_API_ORIGIN, isGuestFilesystemPattern, hasGuestCapability, hasGuestPage, isGuestApproved, isGuestPackageSvgIcon, requestedGuestCapabilities, resolveAttachEntry, resolvePageEntry, resolveAttachMode, resolveIntegrationApi, resolveIntegrationAuth, toPublicService, toPublicIntegration, } from "./manifest.js";
+export { connectHost, HostRequestError } from "./host.js";
+export { clampAttachRequest, clampBadgeCount, clampPromptRequest, clampStartSessionRequest, guestFileScope, isAttachData, isJsonValue, isFileListResult, isFileReadResult, isFileStatResult, isGenerateResult, isFileWriteResult, isGuestFilePath, isGuestAttachItem, isGuestMessageItem, isGuestSessionItem, isServiceStatusResult, isGuestRequestPath, isGuestRequestResult, isHostRequestErrorCode, isPromptResult, isStartSessionResult, readHostMessage, resolveHostRequestErrorCode, } from "./contract.js";
+export { EMPTY_GUEST_CONNECTION, GUEST_BADGE_MAX, GUEST_ITEM_MESSAGE_TEXT_MAX, GUEST_ITEM_SESSION_MAX, GUEST_RESOLVE_ERROR_MAX, GUEST_FILE_CONTENT_MAX, GUEST_FILE_ENTRY_KINDS, GUEST_FILE_LIST_MAX, GUEST_FILE_PATH_MAX, GUEST_GENERATE_OUTPUT_TOKENS_MAX, GUEST_GENERATE_PROMPT_MAX, GUEST_GENERATE_SYSTEM_MAX, GUEST_GENERATE_TEXT_MAX, GUEST_GENERATE_TIMEOUT_MS, GUEST_FILE_STAT_KINDS, SERVICE_STATUS_VALUES, HOST_REQUEST_ERROR_CODES, SESSION_LIFECYCLE_PHASES, START_SESSION_SENT, GUEST_ACCOUNT_MAX, GUEST_SESSION_AGENT_MAX, GUEST_SESSION_MODEL_MAX, GUEST_ATTACH_AUTHOR_MAX, GUEST_ATTACH_BRANCH_MAX, GUEST_ATTACH_DATA_MAX, GUEST_ATTACH_ID_MAX, GUEST_ATTACH_TEXT_MAX, GUEST_ATTACH_TITLE_MAX, GUEST_ATTACH_URL_MAX, GUEST_CLIPBOARD_TEXT_MAX, GUEST_TOAST_MAX, GUEST_COMPOSE_TEXT_MAX, GUEST_REQUEST_BODY_MAX, GUEST_REQUEST_PATH_MAX, GUEST_REQUEST_RESPONSE_MAX, GUEST_REQUEST_TIMEOUT_MS, GUEST_SETTING_VALUE_MAX, } from "./contract.js";