@beeuni/sdk 0.1.0

package/dist/core/client/session-start.js

@@ -0,0 +1,39 @@
+import { ApiError } from '../http/api/errors.js';
+import * as P from '../rest/projects-client/index.js';
+import { setCurrentRuntime } from '../session/current-runtime.js';
+import { getSandboxUrlForExternalId } from '../session/server-store/url-helpers.js';
+import { runtimeNotReadyMessage } from './session-shared.js';
+export function bindSessionStart(projectId, sessionId) {
+    async function startRuntime(readyTimeoutMs) {
+        const deadline = Date.now() + readyTimeoutMs;
+        const remainingMs = () => Math.max(0, deadline - Date.now());
+        let started = await P.startProjectSession(projectId, sessionId, Math.min(30_000, remainingMs()));
+        while (Date.now() < deadline &&
+            (started == null ||
+                ((started.stage === 'provisioning' || started.stage === 'starting') && started.retriable))) {
+            await new Promise((r) => setTimeout(r, Math.min(1_000, remainingMs())));
+            started = await P.startProjectSession(projectId, sessionId, Math.min(30_000, remainingMs()));
+        }
+        const runtimeSessionId = started?.runtime_session_id ?? started?.opencode_session_id;
+        if (!started || started.stage !== 'ready' || !started.sandbox || !runtimeSessionId) {
+            throw new ApiError(runtimeNotReadyMessage(started), {
+                code: 'RUNTIME_UNAVAILABLE',
+            });
+        }
+        const externalId = started.sandbox.external_id;
+        if (!externalId) {
+            throw new ApiError('Session sandbox has no external_id — cannot resolve its runtime URL', {
+                code: 'RUNTIME_UNAVAILABLE',
+            });
+        }
+        const runtimeUrl = getSandboxUrlForExternalId(externalId);
+        setCurrentRuntime(runtimeUrl, externalId);
+        return {
+            runtimeSessionId,
+            opencodeSessionId: runtimeSessionId,
+            runtimeUrl,
+            sandboxId: externalId,
+        };
+    }
+    return startRuntime;
+}

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

@@ -0,0 +1,68 @@
+import { type AuthenticatedRequest } from '../http/authenticated-request.js';
+import { ApiError } from '../http/api/errors.js';
+import type { FileContent, FileNode, FindMatch, GitFileStatus, RuntimeProjectInfo, ServerHealth, UploadResult, WriteFileResult } from './types.js';
+export type * from './types.js';
+export declare const SANDBOX_FS_ROOTS: readonly ["/workspace", "/tmp", "/home", "/opt"];
+export declare function isUnderSandboxRoot(filePath: string): boolean;
+export declare function toSandboxAbsolutePath(filePath: string): string;
+export declare function toDaemonPath(filePath: string): string;
+export declare const toWorkspaceRelative: typeof toDaemonPath;
+export declare function listFiles(dirPath: string, baseUrl?: string): Promise<FileNode[]>;
+export declare function readFile(filePath: string, baseUrl?: string): Promise<FileContent>;
+export declare function fileDownloadRequest(filePath: string, baseUrl?: string): Promise<AuthenticatedRequest>;
+export declare function readBlob(filePath: string, baseUrl?: string): Promise<Blob>;
+export declare function getFileStatus(baseUrl?: string): Promise<GitFileStatus[]>;
+export declare function findFiles(query: string, options?: {
+    type?: 'file' | 'directory';
+    limit?: number;
+}, baseUrl?: string): Promise<string[]>;
+export declare function findText(pattern: string, baseUrl?: string): Promise<FindMatch[]>;
+export declare function uploadTimeoutMsForBytes(bytes?: number): number;
+export interface UploadProgressEvent {
+    loadedBytes: number;
+    totalBytes: number;
+}
+export interface UploadFileOptions {
+    onProgress?: (event: UploadProgressEvent) => void;
+}
+export declare function uploadFile(file: File | Blob, targetPath?: string, filename?: string, baseUrlOrOptions?: string | UploadFileOptions, trailingOptions?: UploadFileOptions): Promise<UploadResult[]>;
+export interface NativeFilePart {
+    uri: string;
+    name: string;
+    type?: string;
+}
+export declare function uploadNativeFile(file: NativeFilePart, targetPath?: string, baseUrl?: string): Promise<UploadResult[]>;
+export declare class FileExistsError extends ApiError {
+    readonly path: string;
+    constructor(path: string);
+}
+export declare function createFile(filePath: string, baseUrl?: string): Promise<UploadResult[]>;
+export declare function copyFile(sourcePath: string, destPath: string, baseUrl?: string): Promise<UploadResult[]>;
+export declare function writeFile(filePath: string, content: Blob | File, baseUrl?: string): Promise<WriteFileResult>;
+export declare function deleteFile(filePath: string, baseUrl?: string): Promise<boolean>;
+export declare function mkdir(dirPath: string, baseUrl?: string): Promise<boolean>;
+export declare function renameFile(from: string, to: string, baseUrl?: string): Promise<boolean>;
+export declare function getCurrentProject(): Promise<RuntimeProjectInfo>;
+export declare function getServerHealth(): Promise<ServerHealth>;
+export declare function isServerReachable(): Promise<boolean>;
+export declare const files: {
+    list: typeof listFiles;
+    read: typeof readFile;
+    readBlob: typeof readBlob;
+    status: typeof getFileStatus;
+    findFiles: typeof findFiles;
+    findText: typeof findText;
+    upload: typeof uploadFile;
+    write: typeof writeFile;
+    create: typeof createFile;
+    copy: typeof copyFile;
+    remove: typeof deleteFile;
+    mkdir: typeof mkdir;
+    rename: typeof renameFile;
+    currentProject: typeof getCurrentProject;
+    health: typeof getServerHealth;
+    isReachable: typeof isServerReachable;
+    toDaemonPath: typeof toDaemonPath;
+    toSandboxAbsolutePath: typeof toSandboxAbsolutePath;
+    toWorkspaceRelative: typeof toDaemonPath;
+};

package/dist/core/files/client.js

@@ -0,0 +1,491 @@
+import { getClient, RuntimeNotReadyError } from '../runtime/client.js';
+import { getActiveRuntimeUrl } from '../session/server-store/active.js';
+import { authenticatedFetch } from '../http/auth.js';
+import { authenticatedRequest } from '../http/authenticated-request.js';
+import { ApiError } from '../http/api/errors.js';
+function unwrap(result) {
+    if (result.error) {
+        const err = result.error;
+        const message = err?.data?.message ||
+            err?.message ||
+            (typeof err?.error === 'string' ? err.error : null) ||
+            'SDK request failed';
+        throw new ApiError(message, {
+            status: err?.response?.status ?? err?.status,
+            response: err?.response,
+            details: err,
+        });
+    }
+    return result.data;
+}
+async function errorMessage(res) {
+    const text = await res.text().catch(() => '');
+    let parsed = null;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch { }
+    return parsed?.error || text || res.statusText || `HTTP ${res.status}`;
+}
+function requireBaseUrl(baseUrl) {
+    const resolved = (baseUrl ?? getActiveRuntimeUrl()).trim();
+    if (!resolved)
+        throw new RuntimeNotReadyError();
+    return resolved;
+}
+async function fetchDaemonJson(relUrl, baseUrl) {
+    const response = await authenticatedFetch(`${requireBaseUrl(baseUrl)}${relUrl}`);
+    if (!response.ok) {
+        throw new ApiError(await errorMessage(response), { status: response.status, response });
+    }
+    return response.json();
+}
+export const SANDBOX_FS_ROOTS = ['/workspace', '/tmp', '/home', '/opt'];
+const NON_WORKSPACE_ROOTS = SANDBOX_FS_ROOTS.filter((root) => root !== '/workspace');
+export function isUnderSandboxRoot(filePath) {
+    return SANDBOX_FS_ROOTS.some((root) => filePath === root || filePath.startsWith(`${root}/`));
+}
+export function toSandboxAbsolutePath(filePath) {
+    if (isUnderSandboxRoot(filePath))
+        return filePath;
+    return `/workspace/${filePath.replace(/^\/+/, '')}`;
+}
+export function toDaemonPath(filePath) {
+    let s = filePath || '';
+    if (s === '/workspace' || s === '/workspace/')
+        return '';
+    if (s.startsWith('/workspace/'))
+        s = s.slice('/workspace/'.length);
+    else if (NON_WORKSPACE_ROOTS.some((root) => s === root || s.startsWith(`${root}/`)))
+        return s;
+    while (s.startsWith('/'))
+        s = s.slice(1);
+    return s;
+}
+export const toWorkspaceRelative = toDaemonPath;
+export async function listFiles(dirPath, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    const daemonPath = toDaemonPath(dirPath) || '.';
+    const nodes = await fetchDaemonJson(`/file?path=${encodeURIComponent(daemonPath)}`, base);
+    return nodes.map((node) => ({ ...node, path: node.absolute || `/workspace/${node.path}` }));
+}
+export async function readFile(filePath, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    const daemonPath = toDaemonPath(filePath);
+    const response = await authenticatedFetch(`${base}/file/content?path=${encodeURIComponent(daemonPath)}`);
+    if (!response.ok) {
+        throw new ApiError(await errorMessage(response), { status: response.status, response });
+    }
+    return response.json();
+}
+async function readFileRaw(filePath, fallbackMime, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    const daemonPath = toDaemonPath(filePath);
+    const response = await authenticatedFetch(`${base}/file/raw?path=${encodeURIComponent(daemonPath)}`);
+    if (!response.ok) {
+        throw new ApiError(await errorMessage(response), { status: response.status, response });
+    }
+    if ((response.headers.get('content-type') || '').includes('text/html')) {
+        throw new ApiError('File could not be loaded (raw byte route unavailable)', {
+            status: response.status,
+            response,
+            code: 'INVALID_CONTENT_TYPE',
+        });
+    }
+    const blob = await response.blob();
+    if (fallbackMime && (!blob.type || blob.type === 'application/octet-stream')) {
+        return new Blob([blob], { type: fallbackMime });
+    }
+    return blob;
+}
+const MAX_CONCURRENT_RAW_READS = 8;
+let rawReadsActive = 0;
+const rawReadWaiters = [];
+async function acquireRawReadSlot() {
+    if (rawReadsActive < MAX_CONCURRENT_RAW_READS) {
+        rawReadsActive++;
+        return;
+    }
+    await new Promise((release) => rawReadWaiters.push(release));
+    rawReadsActive++;
+}
+function releaseRawReadSlot() {
+    rawReadsActive--;
+    rawReadWaiters.shift()?.();
+}
+export function fileDownloadRequest(filePath, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    return authenticatedRequest(`${base}/file/raw?path=${encodeURIComponent(toDaemonPath(filePath))}`);
+}
+export async function readBlob(filePath, baseUrl) {
+    await acquireRawReadSlot();
+    try {
+        const base = requireBaseUrl(baseUrl);
+        try {
+            return await readFileRaw(filePath, undefined, base);
+        }
+        catch { }
+        const result = await readFile(filePath, base);
+        if (result.encoding === 'base64' && result.content) {
+            const bytes = Uint8Array.from(atob(result.content), (c) => c.charCodeAt(0));
+            return new Blob([bytes], { type: result.mimeType || 'application/octet-stream' });
+        }
+        return new Blob([result.content ?? ''], { type: result.mimeType || 'text/plain;charset=utf-8' });
+    }
+    finally {
+        releaseRawReadSlot();
+    }
+}
+export async function getFileStatus(baseUrl) {
+    return fetchDaemonJson(`/file/status`, requireBaseUrl(baseUrl));
+}
+export async function findFiles(query, options, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    const params = new URLSearchParams({ query });
+    if (options?.type)
+        params.set('type', options.type);
+    if (options?.limit)
+        params.set('limit', String(options.limit));
+    return fetchDaemonJson(`/find/file?${params.toString()}`, base);
+}
+export async function findText(pattern, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    const raw = await fetchDaemonJson(`/find?pattern=${encodeURIComponent(pattern)}`, base);
+    return raw.map((item) => ({
+        path: typeof item.path === 'string' ? item.path : (item.path?.text ?? ''),
+        lines: typeof item.lines === 'string' ? item.lines : (item.lines?.text ?? ''),
+        line_number: item.line_number,
+        absolute_offset: item.absolute_offset,
+        submatches: (item.submatches ?? []).map((s) => ({ start: s.start, end: s.end })),
+    }));
+}
+const UPLOAD_RETRY_DELAYS_MS = [400, 1200];
+const isTransient = (s) => s === 408 || s === 429 || s === 502 || s === 503 || s === 504;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function isUnretryableThrow(error) {
+    const name = error?.name;
+    return name === 'TimeoutError' || name === 'AbortError';
+}
+const UPLOAD_TIMEOUT_FLOOR_MS = 30_000;
+const UPLOAD_TIMEOUT_CEILING_MS = 15 * 60_000;
+const UPLOAD_ASSUMED_BYTES_PER_MS = 256;
+export function uploadTimeoutMsForBytes(bytes) {
+    if (typeof bytes !== 'number' || !Number.isFinite(bytes) || bytes <= 0) {
+        return UPLOAD_TIMEOUT_FLOOR_MS;
+    }
+    const scaled = UPLOAD_TIMEOUT_FLOOR_MS + bytes / UPLOAD_ASSUMED_BYTES_PER_MS;
+    return Math.min(UPLOAD_TIMEOUT_CEILING_MS, Math.max(UPLOAD_TIMEOUT_FLOOR_MS, Math.round(scaled)));
+}
+async function uploadErrorMessage(res) {
+    const text = await res.text().catch(() => '');
+    let parsed = null;
+    try {
+        parsed = text ? JSON.parse(text) : null;
+    }
+    catch { }
+    const jsonMessage = parsed?.error || parsed?.message || parsed?.data?.message;
+    if (typeof jsonMessage === 'string' && jsonMessage.trim())
+        return jsonMessage.trim();
+    const contentType = res.headers.get('content-type') || '';
+    if (contentType.includes('text/html') || /<html[\s>]/i.test(text)) {
+        if (res.status === 502 || /bad gateway/i.test(text))
+            return 'Bad gateway while reaching the sandbox upload service. Please retry.';
+        return res.statusText || `HTTP ${res.status}`;
+    }
+    return text.replace(/\s+/g, ' ').trim().slice(0, 500) || res.statusText || `HTTP ${res.status}`;
+}
+async function uploadWithRetry(buildForm, send) {
+    let lastError;
+    for (let attempt = 0; attempt <= UPLOAD_RETRY_DELAYS_MS.length; attempt++) {
+        let res;
+        try {
+            res = await send(buildForm());
+        }
+        catch (err) {
+            lastError = err;
+            if (isUnretryableThrow(err))
+                break;
+            if (attempt === UPLOAD_RETRY_DELAYS_MS.length)
+                break;
+            await sleep(UPLOAD_RETRY_DELAYS_MS[attempt]);
+            continue;
+        }
+        if (res.ok)
+            return res.json();
+        const message = await uploadErrorMessage(res);
+        lastError = new ApiError(`Upload failed (${res.status}): ${message}`, { status: res.status, response: res });
+        if (!isTransient(res.status) || attempt === UPLOAD_RETRY_DELAYS_MS.length)
+            throw lastError;
+        await sleep(UPLOAD_RETRY_DELAYS_MS[attempt]);
+    }
+    if (lastError instanceof ApiError)
+        throw lastError;
+    const message = lastError instanceof Error ? lastError.message : String(lastError || 'request failed');
+    throw new ApiError(`Upload failed: ${message}`);
+}
+const SANDBOX_UPLOAD_CHUNK_BYTES = 8 * 1024 * 1024;
+function verifyLandedSize(result, expected) {
+    if (typeof result?.size !== 'number' || !Number.isFinite(expected))
+        return;
+    if (result.size >= expected)
+        return;
+    throw new ApiError(`Upload verification failed for ${result.path}: expected ${expected} bytes, received ${result.size}`, { code: 'UPLOAD_SIZE_MISMATCH' });
+}
+function notifyUploadProgress(options, event) {
+    try {
+        options?.onProgress?.(event);
+    }
+    catch {
+    }
+}
+function buildUploadForm(file, targetPath, name) {
+    const form = new FormData();
+    const rawPath = (targetPath ?? '').trim();
+    if (rawPath)
+        form.append('path', rawPath.startsWith('/') ? rawPath : `/${rawPath}`);
+    if (name)
+        form.append('filename', name);
+    if (name)
+        form.append('file', file, name);
+    else
+        form.append('file', file);
+    return form;
+}
+function splitSandboxPath(filePath) {
+    const slash = filePath.lastIndexOf('/');
+    if (slash < 0)
+        return { parent: '', name: filePath };
+    return { parent: filePath.slice(0, slash) || '/', name: filePath.slice(slash + 1) };
+}
+export async function uploadFile(file, targetPath, filename, baseUrlOrOptions, trailingOptions) {
+    const baseUrl = typeof baseUrlOrOptions === 'string' ? baseUrlOrOptions : undefined;
+    const options = typeof baseUrlOrOptions === 'string' ? trailingOptions : baseUrlOrOptions;
+    const base = requireBaseUrl(baseUrl);
+    const timeoutMs = uploadTimeoutMsForBytes(file.size);
+    const name = filename || (file instanceof File ? file.name : '') || '';
+    if (file.size <= SANDBOX_UPLOAD_CHUNK_BYTES) {
+        const result = await uploadWithRetry(() => buildUploadForm(file, targetPath, name), (form) => authenticatedFetch(`${base}/file/upload`, { method: 'POST', body: form }, { timeoutMs }));
+        verifyLandedSize(result[0], file.size);
+        notifyUploadProgress(options, { loadedBytes: file.size, totalBytes: file.size });
+        return result;
+    }
+    const reserved = await uploadWithRetry(() => buildUploadForm(new Blob([], { type: file.type }), targetPath, name), (form) => authenticatedFetch(`${base}/file/upload`, { method: 'POST', body: form }, { timeoutMs: uploadTimeoutMsForBytes(0) }));
+    const landedPath = reserved[0]?.path;
+    if (!landedPath) {
+        throw new ApiError('Upload reservation returned no file path', { code: 'UPLOAD_NO_RESULT' });
+    }
+    const destination = splitSandboxPath(landedPath);
+    if (!destination.name) {
+        throw new ApiError(`Upload reservation returned an invalid file path: ${landedPath}`, {
+            code: 'UPLOAD_INVALID_PATH',
+        });
+    }
+    try {
+        for (let offset = 0; offset < file.size; offset += SANDBOX_UPLOAD_CHUNK_BYTES) {
+            const end = Math.min(file.size, offset + SANDBOX_UPLOAD_CHUNK_BYTES);
+            const chunk = file.slice(offset, end, file.type);
+            const appended = await uploadWithRetry(() => {
+                const form = new FormData();
+                if (destination.parent)
+                    form.append('path', destination.parent);
+                form.append('filename', destination.name);
+                form.append('first', offset === 0 ? 'true' : 'false');
+                form.append('offset', String(offset));
+                form.append('file', chunk, destination.name);
+                return form;
+            }, (form) => authenticatedFetch(`${base}/file/append`, { method: 'POST', body: form }, { timeoutMs: uploadTimeoutMsForBytes(chunk.size) }));
+            if (appended.path !== landedPath || appended.size !== end) {
+                throw new ApiError(`Upload verification failed for ${landedPath}: expected ${end} bytes, received ${appended.size}`, { code: 'UPLOAD_SIZE_MISMATCH' });
+            }
+            notifyUploadProgress(options, { loadedBytes: end, totalBytes: file.size });
+        }
+    }
+    catch (error) {
+        await deleteFile(landedPath, base).catch(() => undefined);
+        throw error;
+    }
+    return [{ path: landedPath, size: file.size }];
+}
+export function uploadNativeFile(file, targetPath, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    return uploadWithRetry(() => {
+        const form = new FormData();
+        if (targetPath)
+            form.append('path', targetPath);
+        form.append('file', { uri: file.uri, name: file.name, type: file.type || 'application/octet-stream' });
+        return form;
+    }, (form) => authenticatedFetch(`${base}/file/upload`, { method: 'POST', body: form }, { timeoutMs: NATIVE_UPLOAD_TIMEOUT_MS }));
+}
+const NATIVE_UPLOAD_TIMEOUT_MS = UPLOAD_TIMEOUT_CEILING_MS;
+function uploadToPath(filePath, content, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    const timeoutMs = uploadTimeoutMsForBytes(content.size);
+    return uploadWithRetry(() => {
+        const form = new FormData();
+        form.append(filePath, content, filePath.split('/').pop() || 'file');
+        return form;
+    }, (form) => authenticatedFetch(`${base}/file/upload`, { method: 'POST', body: form }, { timeoutMs }));
+}
+export class FileExistsError extends ApiError {
+    path;
+    constructor(path) {
+        super(`A file or folder already exists at ${path}`, { status: 409, code: 'FILE_EXISTS' });
+        this.name = 'FileExistsError';
+        this.path = path;
+    }
+}
+export async function createFile(filePath, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    const rawPath = filePath.trim();
+    const absolutePath = rawPath.startsWith('/') ? rawPath : `/${rawPath}`;
+    const parts = absolutePath.split('/');
+    const fileName = parts.pop() || 'untitled';
+    const dirPath = parts.join('/') || '/workspace';
+    const target = toSandboxAbsolutePath(`${dirPath}/${fileName}`);
+    let siblings = [];
+    try {
+        siblings = await listFiles(sandboxDirname(target), base);
+    }
+    catch (error) {
+        if (!(error instanceof ApiError && error.status === 404))
+            throw error;
+    }
+    if (siblings.some((node) => node.name === sandboxBasename(target))) {
+        throw new FileExistsError(target);
+    }
+    const written = await placeUpload(target, new Blob([], { type: 'application/octet-stream' }), base, {
+        overwrite: false,
+    });
+    return [{ path: written.path, size: written.bytes }];
+}
+export async function copyFile(sourcePath, destPath, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    return uploadToPath(destPath, await readBlob(sourcePath, base), base);
+}
+function stripTrailingSlashes(value) {
+    let end = value.length;
+    while (end > 0 && value.charCodeAt(end - 1) === 47)
+        end--;
+    return value.slice(0, end);
+}
+function sandboxDirname(absPath) {
+    const index = absPath.lastIndexOf('/');
+    return index <= 0 ? '/' : absPath.slice(0, index);
+}
+function sandboxBasename(absPath) {
+    return absPath.slice(absPath.lastIndexOf('/') + 1);
+}
+function writeToken() {
+    const c = typeof crypto !== 'undefined' ? crypto : undefined;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    if (c?.getRandomValues) {
+        const bytes = new Uint8Array(8);
+        c.getRandomValues(bytes);
+        return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('');
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+export async function writeFile(filePath, content, baseUrl) {
+    const base = requireBaseUrl(baseUrl);
+    const absPath = toSandboxAbsolutePath(stripTrailingSlashes(filePath.trim()));
+    return placeUpload(absPath, content, base, { overwrite: true });
+}
+async function placeUpload(absPath, content, base, options) {
+    const name = sandboxBasename(absPath);
+    if (!name) {
+        throw new ApiError(`writeFile needs a file path, got "${absPath}"`, { code: 'INVALID_PATH' });
+    }
+    const parent = sandboxDirname(absPath);
+    await mkdir(parent, base).catch(() => undefined);
+    const token = writeToken();
+    const results = await uploadFile(content, parent, `.${name}.beeuni-write-${token}`, base);
+    const uploaded = results[0]?.path;
+    if (!uploaded) {
+        throw new ApiError(`Upload returned no file for ${absPath}`, { code: 'UPLOAD_NO_RESULT' });
+    }
+    const actual = toSandboxAbsolutePath(uploaded);
+    try {
+        await moveFile(actual, absPath, base, options.overwrite);
+    }
+    catch (error) {
+        await deleteFile(actual, base).catch(() => undefined);
+        if (!options.overwrite && error instanceof ApiError && error.status === 409) {
+            throw new FileExistsError(absPath);
+        }
+        throw error;
+    }
+    const written = results[0]?.size;
+    return { path: absPath, bytes: typeof written === 'number' ? written : content.size };
+}
+export async function deleteFile(filePath, baseUrl) {
+    const res = await authenticatedFetch(`${requireBaseUrl(baseUrl)}/file`, {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path: filePath }),
+    });
+    if (!res.ok) {
+        throw new ApiError(`Delete failed (${res.status}): ${await errorMessage(res)}`, { status: res.status, response: res });
+    }
+    return res.json();
+}
+export async function mkdir(dirPath, baseUrl) {
+    const res = await authenticatedFetch(`${requireBaseUrl(baseUrl)}/file/mkdir`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path: dirPath }),
+    });
+    if (!res.ok) {
+        throw new ApiError(`Mkdir failed (${res.status}): ${await errorMessage(res)}`, { status: res.status, response: res });
+    }
+    return res.json();
+}
+export async function renameFile(from, to, baseUrl) {
+    return moveFile(from, to, requireBaseUrl(baseUrl), true);
+}
+async function moveFile(from, to, base, overwrite) {
+    const res = await authenticatedFetch(`${base}/file/rename`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(overwrite ? { from, to } : { from, to, overwrite: false }),
+    });
+    if (!res.ok) {
+        throw new ApiError(`Rename failed (${res.status}): ${await errorMessage(res)}`, { status: res.status, response: res });
+    }
+    return res.json();
+}
+export async function getCurrentProject() {
+    return unwrap(await getClient().project.current());
+}
+export async function getServerHealth() {
+    return unwrap(await getClient().global.health());
+}
+export async function isServerReachable() {
+    try {
+        return (await getServerHealth()).healthy === true;
+    }
+    catch {
+        return false;
+    }
+}
+export const files = {
+    list: listFiles,
+    read: readFile,
+    readBlob,
+    status: getFileStatus,
+    findFiles,
+    findText,
+    upload: uploadFile,
+    write: writeFile,
+    create: createFile,
+    copy: copyFile,
+    remove: deleteFile,
+    mkdir,
+    rename: renameFile,
+    currentProject: getCurrentProject,
+    health: getServerHealth,
+    isReachable: isServerReachable,
+    toDaemonPath,
+    toSandboxAbsolutePath,
+    toWorkspaceRelative,
+};

package/dist/core/files/types.d.ts

@@ -0,0 +1,75 @@
+export interface FileNode {
+    name: string;
+    path: string;
+    absolute: string;
+    type: 'file' | 'directory';
+    ignored: boolean;
+}
+export interface FilePatchHunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: string[];
+}
+export interface FilePatch {
+    oldFileName: string;
+    newFileName: string;
+    oldHeader?: string;
+    newHeader?: string;
+    hunks: FilePatchHunk[];
+    index?: string;
+}
+export interface FileContent {
+    type: 'text' | 'binary';
+    content: string;
+    patch?: FilePatch;
+    encoding?: 'base64';
+    mimeType?: string;
+}
+export interface GitFileStatus {
+    path: string;
+    added: number;
+    removed: number;
+    status: 'added' | 'deleted' | 'modified';
+}
+export interface FindMatch {
+    path: string;
+    lines: string;
+    line_number: number;
+    absolute_offset: number;
+    submatches: Array<{
+        start: number;
+        end: number;
+    }>;
+}
+export interface RuntimeProjectInfo {
+    id: string;
+    worktree: string;
+    vcs?: 'git';
+    name?: string;
+    icon?: {
+        url?: string;
+        override?: string;
+        color?: string;
+    };
+    time: {
+        created: number;
+        updated: number;
+        initialized?: number;
+    };
+    sandboxes: string[];
+}
+export interface ServerHealth {
+    healthy: boolean;
+    version: string;
+}
+export interface UploadResult {
+    path: string;
+    size: number;
+}
+export interface WriteFileResult {
+    path: string;
+    bytes: number;
+}
+export type OpenCodeProjectInfo = RuntimeProjectInfo;

package/dist/core/files/types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/http/abort-error.d.ts

@@ -0,0 +1,5 @@
+export declare function isAbortError(error: unknown): boolean;
+export declare const ABORT_REASONS: readonly ["user", "runtime-disposed", "orphan-finalized", "wake"];
+export type AbortReason = (typeof ABORT_REASONS)[number];
+export declare const ABORT_REASONS_NOT_YET_EMITTED: readonly ["orphan-finalized", "wake"];
+export declare function abortErrorReason(error: unknown): AbortReason | undefined;