@beeuni/sdk 0.1.0

package/dist/core/runtime/beeuni-master.js

@@ -0,0 +1,264 @@
+import { authenticatedFetch } from '../http/auth.js';
+async function beeuniMasterRequest(baseUrl, path, init, fetchOptions) {
+    let base = baseUrl;
+    while (base.endsWith('/'))
+        base = base.slice(0, -1);
+    const response = await authenticatedFetch(`${base}${path}`, {
+        ...init,
+        headers: {
+            'Content-Type': 'application/json',
+            ...init?.headers,
+        },
+    }, fetchOptions);
+    const text = await response.text();
+    let body = {};
+    try {
+        body = text ? JSON.parse(text) : {};
+    }
+    catch {
+        body = {};
+    }
+    if (!response.ok) {
+        throw new Error(body?.error || body?.message || body?.details || text.slice(0, 200) || `Request failed with ${response.status}`);
+    }
+    return body;
+}
+export async function listTasks(baseUrl, params = {}) {
+    const search = new URLSearchParams();
+    if (params.projectId)
+        search.set('project_id', params.projectId);
+    if (params.status)
+        search.set('status', params.status);
+    const qs = search.toString() ? `?${search}` : '';
+    return beeuniMasterRequest(baseUrl, `/beeuni/tasks${qs}`);
+}
+export async function getTask(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tasks/${encodeURIComponent(id)}`);
+}
+export async function listTaskEvents(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tasks/${encodeURIComponent(id)}/events`);
+}
+export async function getTaskStatus(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tasks/${encodeURIComponent(id)}/status`);
+}
+export async function createTask(baseUrl, data) {
+    return beeuniMasterRequest(baseUrl, '/beeuni/tasks', {
+        method: 'POST',
+        body: JSON.stringify(data),
+    });
+}
+export async function updateTask(baseUrl, id, data) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tasks/${encodeURIComponent(id)}`, {
+        method: 'PATCH',
+        body: JSON.stringify(data),
+    });
+}
+export async function startTask(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tasks/${encodeURIComponent(id)}/start`, {
+        method: 'POST',
+    });
+}
+export async function approveTask(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tasks/${encodeURIComponent(id)}/approve`, {
+        method: 'POST',
+    });
+}
+export async function deleteTask(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tasks/${encodeURIComponent(id)}`, {
+        method: 'DELETE',
+    });
+}
+export async function listTickets(baseUrl, projectId) {
+    const qs = projectId ? `?project_id=${encodeURIComponent(projectId)}` : '';
+    return beeuniMasterRequest(baseUrl, `/beeuni/tickets${qs}`);
+}
+export async function getTicket(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tickets/${encodeURIComponent(id)}`);
+}
+export async function listTicketEvents(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tickets/${encodeURIComponent(id)}/events`);
+}
+export async function createTicket(baseUrl, body) {
+    return beeuniMasterRequest(baseUrl, '/beeuni/tickets', {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+}
+export async function updateTicket(baseUrl, id, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tickets/${encodeURIComponent(id)}`, {
+        method: 'PATCH',
+        body: JSON.stringify(body),
+    });
+}
+export async function updateTicketStatus(baseUrl, id, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tickets/${encodeURIComponent(id)}/status`, {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+}
+export async function assignTicket(baseUrl, id, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tickets/${encodeURIComponent(id)}/assign`, {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+}
+export async function unassignTicket(baseUrl, id, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tickets/${encodeURIComponent(id)}/unassign`, {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+}
+export async function commentTicket(baseUrl, id, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tickets/${encodeURIComponent(id)}/comments`, {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+}
+export async function deleteTicket(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/tickets/${encodeURIComponent(id)}`, { method: 'DELETE' });
+}
+export async function listColumns(baseUrl, projectId) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/columns`);
+}
+export async function replaceColumns(baseUrl, projectId, columns) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/columns`, {
+        method: 'PUT',
+        body: JSON.stringify({ columns }),
+    });
+}
+export async function listFields(baseUrl, projectId) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/fields`);
+}
+export async function replaceFields(baseUrl, projectId, fields) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/fields`, {
+        method: 'PUT',
+        body: JSON.stringify({ fields }),
+    });
+}
+export async function listTemplates(baseUrl, projectId) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/templates`);
+}
+export async function replaceTemplates(baseUrl, projectId, templates) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/templates`, { method: 'PUT', body: JSON.stringify({ templates }) });
+}
+export async function ensurePmSession(baseUrl, projectId) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/pm-session`, {
+        method: 'POST',
+    });
+}
+export async function listProjectAgents(baseUrl, projectId) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/agents`);
+}
+export async function createProjectAgent(baseUrl, projectId, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/agents`, {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+}
+export async function updateProjectAgent(baseUrl, projectId, slug, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/agents/${encodeURIComponent(slug)}`, { method: 'PATCH', body: JSON.stringify(body) });
+}
+export async function deleteProjectAgent(baseUrl, projectId, slug) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/agents/${encodeURIComponent(slug)}`, { method: 'DELETE' });
+}
+export async function getAgentPersona(baseUrl, projectId, slug) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/agents/${encodeURIComponent(slug)}/persona`);
+}
+export async function getProjectActivity(baseUrl, projectId, limit = 200) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/activity?limit=${limit}`);
+}
+export async function listBeeuniProjects(baseUrl) {
+    return beeuniMasterRequest(baseUrl, '/beeuni/projects');
+}
+export async function getBeeuniProject(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(id)}`);
+}
+export async function getBeeuniProjectBySession(baseUrl, sessionId) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/by-session/${encodeURIComponent(sessionId)}`);
+}
+export async function listBeeuniProjectSessions(baseUrl, projectId) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/sessions`);
+}
+export async function deleteBeeuniProject(baseUrl, id) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(id)}`, { method: 'DELETE' });
+}
+export async function patchBeeuniProject(baseUrl, id, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(id)}`, {
+        method: 'PATCH',
+        body: JSON.stringify(body),
+    });
+}
+export async function listMilestones(baseUrl, projectId, statusFilter = 'all') {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/milestones?status=${statusFilter}`);
+}
+export async function getMilestone(baseUrl, projectId, ref) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/milestones/${encodeURIComponent(ref)}`);
+}
+export async function listMilestoneEvents(baseUrl, projectId, ref) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/milestones/${encodeURIComponent(ref)}/events`);
+}
+export async function createMilestone(baseUrl, projectId, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/milestones`, { method: 'POST', body: JSON.stringify(body) });
+}
+export async function updateMilestone(baseUrl, projectId, ref, patch) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/milestones/${encodeURIComponent(ref)}`, { method: 'PATCH', body: JSON.stringify(patch) });
+}
+export async function closeMilestone(baseUrl, projectId, ref, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/milestones/${encodeURIComponent(ref)}/close`, { method: 'POST', body: JSON.stringify(body) });
+}
+export async function reopenMilestone(baseUrl, projectId, ref) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/milestones/${encodeURIComponent(ref)}/reopen`, { method: 'POST' });
+}
+export async function deleteMilestone(baseUrl, projectId, ref) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/milestones/${encodeURIComponent(ref)}`, { method: 'DELETE' });
+}
+export async function listCredentials(baseUrl, projectId) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/credentials`);
+}
+export async function listCredentialEvents(baseUrl, projectId, name) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/credentials/${encodeURIComponent(name)}/events`);
+}
+export async function upsertCredential(baseUrl, projectId, body) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/credentials`, { method: 'POST', body: JSON.stringify(body) });
+}
+export async function revealCredential(baseUrl, projectId, name) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/credentials/${encodeURIComponent(name)}`);
+}
+export async function deleteCredential(baseUrl, projectId, name) {
+    return beeuniMasterRequest(baseUrl, `/beeuni/projects/${encodeURIComponent(projectId)}/credentials/${encodeURIComponent(name)}`, { method: 'DELETE' });
+}
+const SERVICES_TIMEOUT_MS = 10_000;
+const servicesFetchOptions = { retryOnAuthError: false };
+function servicesRequest(baseUrl, path, init) {
+    return beeuniMasterRequest(baseUrl, path, { signal: AbortSignal.timeout(SERVICES_TIMEOUT_MS), ...init }, servicesFetchOptions);
+}
+export async function listServices(baseUrl, includeAll = false) {
+    const query = includeAll ? '?all=true' : '';
+    const data = await servicesRequest(baseUrl, `/beeuni/services${query}`);
+    return data.services ?? [];
+}
+export async function listServiceTemplates(baseUrl) {
+    const data = await servicesRequest(baseUrl, '/beeuni/services/templates');
+    return data.templates ?? [];
+}
+export async function getServiceLogs(baseUrl, serviceId) {
+    const data = await servicesRequest(baseUrl, `/beeuni/services/${encodeURIComponent(serviceId)}/logs`);
+    return data.logs ?? [];
+}
+export async function serviceAction(baseUrl, serviceId, action) {
+    const isDelete = action === 'delete';
+    const path = isDelete
+        ? `/beeuni/services/${encodeURIComponent(serviceId)}`
+        : `/beeuni/services/${encodeURIComponent(serviceId)}/${action}`;
+    return servicesRequest(baseUrl, path, { method: isDelete ? 'DELETE' : 'POST' });
+}
+export async function reconcileServices(baseUrl, reload) {
+    const path = `/beeuni/services/reconcile${reload ? '?reload=true' : ''}`;
+    return servicesRequest(baseUrl, path, { method: 'POST' });
+}
+export async function registerService(baseUrl, payload) {
+    return servicesRequest(baseUrl, '/beeuni/services/register', {
+        method: 'POST',
+        body: JSON.stringify(payload),
+    });
+}

package/dist/core/runtime/client.d.ts

@@ -0,0 +1,30 @@
+import { createRuntimeRestClient, type RuntimeClient, type RuntimeClientConfig } from "./runtime-rest-client.js";
+export * from "./transcript-types.js";
+export type * from "./runtime-types.js";
+export type { RuntimeClient, RuntimeClientConfig, RuntimeEventMessage, RuntimeEventStreamOptions, RuntimeEventTransport, RuntimeRequestOptions, RuntimeResult, } from "./runtime-rest-client.js";
+export type { createRuntimeRestClient as createRuntimeClient };
+export type OpencodeClient = RuntimeClient;
+export type OpencodeClientConfig = RuntimeClientConfig;
+export type createOpencodeClient = typeof createRuntimeRestClient;
+export { listEnv, setEnv, deleteEnv, env } from "./env.js";
+export { triggersRequest } from "./triggers.js";
+export { listBeeuniPty, createBeeuniPty, updateBeeuniPty, removeBeeuniPty, getBeeuniPtyWebSocketUrl, beeuniPty, classifyPtyClose, sanitizePtyChunk, type BeeuniPty, type PtyCloseAction, } from "./pty.js";
+export * from "./beeuni-master.js";
+export declare class RuntimeNotReadyError extends Error {
+    constructor(message?: string);
+}
+export declare function getClient(): RuntimeClient;
+export declare function getClientForUrl(url: string): RuntimeClient;
+export declare function dropClientForUrl(url: string): void;
+export declare function resetClient(): void;
+export declare function getPublicClientForUrl(url: string): RuntimeClient;
+export declare function dropPublicClientForUrl(url: string): void;
+export declare function resetPublicClient(): void;
+export type SystemReloadMode = 'dispose-only' | 'full';
+export interface SystemReloadResult {
+    success: boolean;
+    mode: SystemReloadMode;
+    steps: string[];
+    errors: string[];
+}
+export declare function systemReload(mode: SystemReloadMode): Promise<SystemReloadResult>;

package/dist/core/runtime/client.js

@@ -0,0 +1,124 @@
+import { createRuntimeRestClient, } from "./runtime-rest-client.js";
+export * from "./transcript-types.js";
+import { authenticatedFetch } from "../http/auth.js";
+import { isConfigured } from "../http/config.js";
+import { platformEventTransport } from "../stream/platform-event-transport.js";
+import { getActiveRuntimeUrl } from "../session/server-store/active.js";
+import { ApiError } from "../http/api/errors.js";
+export { listEnv, setEnv, deleteEnv, env } from "./env.js";
+export { triggersRequest } from "./triggers.js";
+export { listBeeuniPty, createBeeuniPty, updateBeeuniPty, removeBeeuniPty, getBeeuniPtyWebSocketUrl, beeuniPty, classifyPtyClose, sanitizePtyChunk, } from "./pty.js";
+export * from "./beeuni-master.js";
+const clientsByUrl = new Map();
+const MAX_CLIENTS_BY_URL = 256;
+export class RuntimeNotReadyError extends Error {
+    constructor(message = '[opencode-sdk] Server URL not ready — sandbox is still loading') {
+        super(message);
+        this.name = 'RuntimeNotReadyError';
+    }
+}
+export function getClient() {
+    const url = getActiveRuntimeUrl();
+    if (!url) {
+        throw new RuntimeNotReadyError();
+    }
+    return getClientForUrl(url);
+}
+export function getClientForUrl(url) {
+    if (!url) {
+        throw new Error('[opencode-sdk] getClientForUrl called without a url');
+    }
+    const existing = clientsByUrl.get(url);
+    if (existing) {
+        clientsByUrl.delete(url);
+        clientsByUrl.set(url, existing);
+        return existing;
+    }
+    if (!isConfigured()) {
+        throw new Error('[opencode-sdk] No auth token provider configured — call configureBeeuni()/createBeeuni() before talking to a sandbox runtime.');
+    }
+    const client = createRuntimeRestClient({
+        baseUrl: url,
+        fetch: authenticatedFetch,
+        eventTransport: platformEventTransport,
+    });
+    clientsByUrl.set(url, client);
+    if (clientsByUrl.size > MAX_CLIENTS_BY_URL) {
+        clientsByUrl.delete(clientsByUrl.keys().next().value);
+    }
+    return client;
+}
+export function dropClientForUrl(url) {
+    clientsByUrl.delete(url);
+}
+export function resetClient() {
+    clientsByUrl.clear();
+}
+const publicClientsByUrl = new Map();
+export function getPublicClientForUrl(url) {
+    if (!url) {
+        throw new Error('[opencode-sdk] getPublicClientForUrl called without a url');
+    }
+    const existing = publicClientsByUrl.get(url);
+    if (existing)
+        return existing;
+    const client = createRuntimeRestClient({ baseUrl: url, fetch });
+    publicClientsByUrl.set(url, client);
+    return client;
+}
+export function dropPublicClientForUrl(url) {
+    publicClientsByUrl.delete(url);
+}
+export function resetPublicClient() {
+    publicClientsByUrl.clear();
+}
+async function daemonErrorMessage(res) {
+    const text = await res.text().catch(() => '');
+    try {
+        const parsed = JSON.parse(text);
+        return parsed?.error || parsed?.message || text || res.statusText || `HTTP ${res.status}`;
+    }
+    catch {
+        return text || res.statusText || `HTTP ${res.status}`;
+    }
+}
+export async function systemReload(mode) {
+    const url = getActiveRuntimeUrl();
+    if (!url) {
+        throw new ApiError('[opencode-sdk] Server URL not ready — sandbox is still loading', {
+            code: 'RUNTIME_UNAVAILABLE',
+        });
+    }
+    const path = mode === 'full' ? '/beeuni/refresh' : '/global/dispose';
+    const response = await authenticatedFetch(`${url}${path}`, { method: 'POST' });
+    const contentType = response.headers.get('content-type') ?? '';
+    const isJson = /^application\/([\w.+-]+\+)?json\b/i.test(contentType.trim());
+    if (!response.ok) {
+        throw new ApiError(`System reload failed (${response.status}): ${await daemonErrorMessage(response)}`, {
+            status: response.status,
+            response,
+            code: 'RUNTIME_UNAVAILABLE',
+        });
+    }
+    if (!isJson) {
+        throw new ApiError(`System reload endpoint is unavailable on this sandbox (${path})`, {
+            status: response.status,
+            response,
+            code: 'RUNTIME_UNAVAILABLE',
+        });
+    }
+    let body;
+    try {
+        body = await response.json();
+    }
+    catch (err) {
+        throw new ApiError(`System reload returned malformed JSON from ${path}: ${err instanceof Error ? err.message : String(err)}`, { status: response.status, response, code: 'RUNTIME_UNAVAILABLE' });
+    }
+    const success = body === true || (typeof body === 'object' && body !== null && body.ok === true);
+    return {
+        success,
+        mode,
+        steps: success ? [mode === 'full' ? 'refreshed workspace and restarted runtime' : 'reloaded config in place'] : [],
+        errors: success ? [] : [`the sandbox did not confirm the reload (${path})`],
+    };
+}

package/dist/core/runtime/env.d.ts

@@ -0,0 +1,8 @@
+export declare function listEnv(baseUrl: string): Promise<Record<string, string>>;
+export declare function setEnv(baseUrl: string, key: string, value: string): Promise<void>;
+export declare function deleteEnv(baseUrl: string, key: string): Promise<void>;
+export declare const env: {
+    list: typeof listEnv;
+    set: typeof setEnv;
+    delete: typeof deleteEnv;
+};

package/dist/core/runtime/env.js

@@ -0,0 +1,42 @@
+import { authenticatedFetch } from '../http/auth.js';
+async function envErrorMessage(res, fallback) {
+    const body = await res.json().catch(() => ({}));
+    return body?.error || res.statusText || fallback;
+}
+function requireBaseUrl(baseUrl) {
+    if (!baseUrl) {
+        throw new Error('[opencode-sdk] Server URL not ready — sandbox is still loading');
+    }
+    return baseUrl;
+}
+export async function listEnv(baseUrl) {
+    const url = requireBaseUrl(baseUrl);
+    const res = await authenticatedFetch(`${url}/env`);
+    if (!res.ok)
+        throw new Error(await envErrorMessage(res, 'Failed to load secrets'));
+    const data = await res.json();
+    return data.secrets ?? {};
+}
+export async function setEnv(baseUrl, key, value) {
+    const url = requireBaseUrl(baseUrl);
+    const res = await authenticatedFetch(`${url}/env/${encodeURIComponent(key)}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value }),
+    });
+    if (!res.ok)
+        throw new Error(await envErrorMessage(res, 'Failed to save secret'));
+}
+export async function deleteEnv(baseUrl, key) {
+    const url = requireBaseUrl(baseUrl);
+    const res = await authenticatedFetch(`${url}/env/${encodeURIComponent(key)}`, {
+        method: 'DELETE',
+    });
+    if (!res.ok)
+        throw new Error(await envErrorMessage(res, 'Failed to delete secret'));
+}
+export const env = {
+    list: listEnv,
+    set: setEnv,
+    delete: deleteEnv,
+};

package/dist/core/runtime/pty.d.ts

@@ -0,0 +1,43 @@
+export interface BeeuniPty {
+    id: string;
+    title: string;
+    command: string;
+    args: string[];
+    cwd: string;
+    status: 'running' | 'exited';
+    pid: number;
+    exitCode?: number;
+}
+export declare function listBeeuniPty(baseUrl: string): Promise<BeeuniPty[]>;
+export declare function createBeeuniPty(baseUrl: string, body?: {
+    command?: string;
+    args?: string[];
+    cwd?: string;
+    title?: string;
+    env?: Record<string, string>;
+}): Promise<BeeuniPty>;
+export declare function updateBeeuniPty(baseUrl: string, ptyId: string, body: {
+    title?: string;
+    size?: {
+        rows: number;
+        cols: number;
+    };
+}): Promise<BeeuniPty>;
+export declare function removeBeeuniPty(baseUrl: string, ptyId: string): Promise<void>;
+export declare function getBeeuniPtyWebSocketUrl(ptyId: string, baseUrl: string, opts?: {
+    wake?: boolean;
+}): Promise<string>;
+export type PtyCloseAction = 'ended' | 'reconnect' | 'replace';
+export declare function classifyPtyClose(input: {
+    code: number;
+    reason: string;
+    hadError: boolean;
+}): PtyCloseAction;
+export declare function sanitizePtyChunk(chunk: string): string;
+export declare const beeuniPty: {
+    list: typeof listBeeuniPty;
+    create: typeof createBeeuniPty;
+    update: typeof updateBeeuniPty;
+    remove: typeof removeBeeuniPty;
+    webSocketUrl: typeof getBeeuniPtyWebSocketUrl;
+};

package/dist/core/runtime/pty.js

@@ -0,0 +1,117 @@
+import { authenticatedFetch, getAuthToken } from '../http/auth.js';
+import { stripTrailingSlashes } from '../../platform/strings.js';
+async function ptyErrorMessage(res, fallback) {
+    const body = await res.json().catch(() => ({}));
+    return body?.error || body?.message || res.statusText || fallback;
+}
+function requireBaseUrl(baseUrl) {
+    if (!baseUrl) {
+        throw new Error('[beeuni-pty] Server URL not ready — sandbox is still loading');
+    }
+    return stripTrailingSlashes(baseUrl);
+}
+export async function listBeeuniPty(baseUrl) {
+    const url = requireBaseUrl(baseUrl);
+    const res = await authenticatedFetch(`${url}/beeuni/pty`);
+    if (!res.ok)
+        throw new Error(await ptyErrorMessage(res, 'Failed to list terminals'));
+    return res.json();
+}
+export async function createBeeuniPty(baseUrl, body) {
+    const url = requireBaseUrl(baseUrl);
+    const res = await authenticatedFetch(`${url}/beeuni/pty`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body ?? {}),
+    });
+    if (!res.ok)
+        throw new Error(await ptyErrorMessage(res, 'Failed to create terminal'));
+    return res.json();
+}
+export async function updateBeeuniPty(baseUrl, ptyId, body) {
+    const url = requireBaseUrl(baseUrl);
+    const res = await authenticatedFetch(`${url}/beeuni/pty/${encodeURIComponent(ptyId)}`, {
+        method: 'PATCH',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok)
+        throw new Error(await ptyErrorMessage(res, 'Failed to update terminal'));
+    return res.json();
+}
+export async function removeBeeuniPty(baseUrl, ptyId) {
+    const url = requireBaseUrl(baseUrl);
+    const res = await authenticatedFetch(`${url}/beeuni/pty/${encodeURIComponent(ptyId)}`, { method: 'DELETE' });
+    if (!res.ok)
+        throw new Error(await ptyErrorMessage(res, 'Failed to remove terminal'));
+}
+export async function getBeeuniPtyWebSocketUrl(ptyId, baseUrl, opts) {
+    const base = requireBaseUrl(baseUrl);
+    const wsBase = (() => {
+        try {
+            const parsed = new URL(base);
+            if (parsed.protocol === 'https:')
+                parsed.protocol = 'wss:';
+            else if (parsed.protocol === 'http:')
+                parsed.protocol = 'ws:';
+            if (typeof window !== 'undefined' && window.location.protocol === 'https:' && parsed.protocol === 'ws:') {
+                parsed.protocol = 'wss:';
+            }
+            return stripTrailingSlashes(parsed.toString());
+        }
+        catch {
+            return base.replace('https://', 'wss://').replace('http://', 'ws://');
+        }
+    })();
+    const connectUrl = `${wsBase}/beeuni/pty/${encodeURIComponent(ptyId)}/connect`;
+    const params = new URLSearchParams();
+    const token = await getAuthToken();
+    if (token)
+        params.set('token', token);
+    if (opts?.wake)
+        params.set('wake', '1');
+    const query = params.toString();
+    if (!query)
+        return connectUrl;
+    return `${connectUrl}${connectUrl.includes('?') ? '&' : '?'}${query}`;
+}
+export function classifyPtyClose(input) {
+    const reason = input.reason.trim().toLowerCase();
+    if (reason.includes('pty not found'))
+        return 'replace';
+    if (reason.includes('pty exited'))
+        return 'ended';
+    if (input.hadError ||
+        reason.includes('idle timeout') ||
+        reason.includes('upstream error') ||
+        input.code !== 1000) {
+        return 'reconnect';
+    }
+    return 'ended';
+}
+const ESC = '\x1b';
+const BEL = '\x07';
+const NUL = '\x00';
+const ST = `(?:${BEL}|${ESC}\\\\)`;
+const PTY_NOISE = [
+    new RegExp(`${ESC}\\]697;[^${BEL}${ESC}]*${ST}`, 'g'),
+    new RegExp(`${NUL}?\\{"cursor":\\d+\\}`, 'g'),
+    new RegExp(`${ESC}\\][0-9]+;rgb:[0-9a-fA-F/]+${ST}`, 'g'),
+    new RegExp(`${ESC}\\]4;[0-9]+;rgb:[0-9a-fA-F/]+${ST}`, 'g'),
+    new RegExp(`${ESC}\\[\\??[0-9;]*\\$y`, 'g'),
+    new RegExp(`${ESC}\\[\\d+;\\d+R`, 'g'),
+    new RegExp(`${ESC}\\[\\?[0-9;]*c`, 'g'),
+];
+export function sanitizePtyChunk(chunk) {
+    let text = chunk;
+    for (const pattern of PTY_NOISE)
+        text = text.replace(pattern, '');
+    return text;
+}
+export const beeuniPty = {
+    list: listBeeuniPty,
+    create: createBeeuniPty,
+    update: updateBeeuniPty,
+    remove: removeBeeuniPty,
+    webSocketUrl: getBeeuniPtyWebSocketUrl,
+};