withruntime 0.4.0 → 0.5.0

package/dist/daytona/errors.js

@@ -0,0 +1,182 @@
+import { RuntimeError } from "../errors.js";
+/* Daytona's error classes by the same names and parents, so a
+   `catch (e) { if (e instanceof DaytonaNotFoundError) ... }` written for
+   Daytona keeps working. One made from a Runtime answer carries Runtime's
+   `code`, `hint` and `requestId`, and the original error as `cause`. */
+export const SOURCE_API = "DAYTONA_API";
+export const SOURCE_DAEMON = "DAYTONA_DAEMON";
+export const SOURCE_PROXY = "DAYTONA_PROXY";
+export class DaytonaError extends Error {
+    statusCode;
+    code;
+    source;
+    headers;
+    hint;
+    requestId;
+    constructor(message, statusCode, headers, code, source) {
+        super(message);
+        this.name = new.target.name;
+        if (statusCode !== undefined)
+            this.statusCode = statusCode;
+        if (headers !== undefined)
+            this.headers = headers;
+        if (code !== undefined)
+            this.code = code;
+        if (source !== undefined)
+            this.source = source;
+    }
+    /** Daytona's older name for `code`. */
+    get errorCode() {
+        return this.code;
+    }
+}
+export class DaytonaBadRequestError extends DaytonaError {
+}
+export class DaytonaAuthenticationError extends DaytonaError {
+}
+export class DaytonaForbiddenError extends DaytonaError {
+}
+export class DaytonaNotFoundError extends DaytonaError {
+}
+export class DaytonaTimeoutError extends DaytonaError {
+}
+export class DaytonaConflictError extends DaytonaError {
+}
+export class DaytonaGoneError extends DaytonaError {
+}
+export class DaytonaUnprocessableEntityError extends DaytonaError {
+}
+export class DaytonaRateLimitError extends DaytonaError {
+}
+export class DaytonaInternalServerError extends DaytonaError {
+}
+export class DaytonaBadGatewayError extends DaytonaError {
+}
+export class DaytonaServiceUnavailableError extends DaytonaError {
+}
+export class DaytonaValidationError extends DaytonaBadRequestError {
+}
+export class DaytonaAuthorizationError extends DaytonaForbiddenError {
+}
+export class DaytonaInvalidArgumentError extends DaytonaValidationError {
+}
+export class DaytonaConnectionError extends DaytonaError {
+}
+export class DaytonaConnectionTimeoutError extends DaytonaConnectionError {
+}
+export class DaytonaGitAuthFailedError extends DaytonaAuthenticationError {
+}
+export class DaytonaGitRepoNotFoundError extends DaytonaNotFoundError {
+}
+export class DaytonaGitBranchNotFoundError extends DaytonaNotFoundError {
+}
+export class DaytonaGitBranchExistsError extends DaytonaConflictError {
+}
+export class DaytonaGitPushRejectedError extends DaytonaConflictError {
+}
+export class DaytonaGitDirtyWorktreeError extends DaytonaConflictError {
+}
+export class DaytonaGitMergeConflictError extends DaytonaConflictError {
+}
+export class DaytonaGitTransportFailedError extends DaytonaBadGatewayError {
+}
+export class DaytonaGitRemoteRejectedError extends DaytonaUnprocessableEntityError {
+}
+export class DaytonaFileNotFoundError extends DaytonaNotFoundError {
+}
+export class DaytonaFileAccessDeniedError extends DaytonaForbiddenError {
+}
+export class DaytonaInvalidFilePathError extends DaytonaBadRequestError {
+}
+export class DaytonaFileReadFailedError extends DaytonaInternalServerError {
+}
+export class DaytonaLspServerNotInitializedError extends DaytonaBadRequestError {
+}
+export class DaytonaProcessExecutionTimeoutError extends DaytonaTimeoutError {
+}
+export class DaytonaProcessNotFoundError extends DaytonaNotFoundError {
+}
+export class DaytonaSessionEndedError extends DaytonaGoneError {
+}
+export class DaytonaCommandAlreadyCompletedError extends DaytonaGoneError {
+}
+export class DaytonaA11yUnavailableError extends DaytonaServiceUnavailableError {
+}
+export class DaytonaRecordingStillActiveError extends DaytonaConflictError {
+}
+export class DaytonaRecordingFfmpegNotFoundError extends DaytonaServiceUnavailableError {
+}
+/** A call that Daytona supports and Runtime does not, or not in the same
+ * way. Thrown before anything is done, never after doing something
+ * different. `feature` names what was asked for; `alternative` says what to
+ * use on Runtime instead. */
+export class NotSupportedError extends DaytonaError {
+    feature;
+    alternative;
+    constructor(feature, alternative, message) {
+        super(message ?? `${feature} is not supported on Runtime. ${alternative}`, undefined, undefined, "not_supported");
+        this.feature = feature;
+        this.alternative = alternative;
+    }
+}
+const BY_STATUS = {
+    400: DaytonaBadRequestError,
+    401: DaytonaAuthenticationError,
+    403: DaytonaForbiddenError,
+    404: DaytonaNotFoundError,
+    408: DaytonaTimeoutError,
+    409: DaytonaConflictError,
+    410: DaytonaGoneError,
+    413: DaytonaBadRequestError,
+    422: DaytonaUnprocessableEntityError,
+    429: DaytonaRateLimitError,
+    500: DaytonaInternalServerError,
+    502: DaytonaBadGatewayError,
+    503: DaytonaServiceUnavailableError,
+    504: DaytonaTimeoutError,
+};
+/** Turns a Runtime SDK error into the Daytona error a caller written for
+ * Daytona expects. Anything that is not a Runtime error passes through. */
+export function translate(error, subject = "other") {
+    if (!(error instanceof RuntimeError))
+        return error;
+    const message = [
+        error.message,
+        error.hint ? `Hint: ${error.hint}` : "",
+        error.requestId ? `Request: ${error.requestId}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+    let out;
+    if (error.status === 503 && error.code.endsWith("_unavailable"))
+        out = new NotSupportedError(error.code.replace(/_unavailable$/, ""), error.hint ?? "", message);
+    else if (error.code === "file_not_found" || (error.status === 404 && subject === "file"))
+        out = new DaytonaFileNotFoundError(message);
+    else if (error.status === 404 && subject === "process")
+        out = new DaytonaProcessNotFoundError(message);
+    else if (error.code === "command_timeout")
+        out = new DaytonaProcessExecutionTimeoutError(message);
+    else if (error.status === 0)
+        out = new DaytonaConnectionError(message);
+    else
+        out = new (BY_STATUS[error.status] ?? DaytonaError)(message);
+    if (error.status)
+        out.statusCode = error.status;
+    if (!(out instanceof NotSupportedError))
+        out.code = error.code;
+    if (error.hint)
+        out.hint = error.hint;
+    if (error.requestId)
+        out.requestId = error.requestId;
+    out.cause = error;
+    return out;
+}
+/** Runs `work`, turning any Runtime error into its Daytona counterpart. */
+export async function guard(subject, work) {
+    try {
+        return await work();
+    }
+    catch (error) {
+        throw translate(error, subject);
+    }
+}

package/dist/daytona/filesystem.d.ts

@@ -0,0 +1,84 @@
+import type { Readable } from "node:stream";
+import { type SandboxContext } from "./context.js";
+export interface FileInfo {
+    name: string;
+    isDir: boolean;
+    size: number;
+    modTime: string;
+    mode: string;
+    permissions: string;
+    /** Runtime's listing does not say who owns a file: always "". */
+    owner: string;
+    group: string;
+}
+export interface Match {
+    file: string;
+    line: number;
+    content: string;
+}
+export interface ReplaceResult {
+    file?: string;
+    success?: boolean;
+    error?: string;
+}
+export interface SearchFilesResponse {
+    files: string[];
+}
+export type FilePermissionsParams = {
+    group?: string;
+    mode?: string;
+    owner?: string;
+};
+export interface FileUpload {
+    source: string | Buffer | Uint8Array;
+    destination: string;
+}
+export interface FileDownloadRequest {
+    source: string;
+    destination?: string;
+}
+export interface FileDownloadResponse {
+    source: string;
+    result?: Buffer | string;
+    error?: string;
+    errorDetails?: {
+        message: string;
+        statusCode?: number;
+        code?: string;
+        source?: string;
+    };
+}
+export type UploadSource = Buffer | Uint8Array | string | Readable | ReadableStream<Uint8Array>;
+/** `sandbox.fs`: Daytona's file calls over Runtime's files API. Relative
+ * paths resolve from the working directory, /workspace on Runtime. */
+export declare class FileSystem {
+    #private;
+    constructor(ctx: SandboxContext);
+    /** Makes a directory and its parents, with `mode` (such as "755"). */
+    createFolder(path: string, mode: string): Promise<void>;
+    deleteFile(path: string, recursive?: boolean): Promise<void>;
+    /** The file's bytes, or with a local path, the file written there. */
+    downloadFile(remotePath: string, timeout?: number): Promise<Buffer>;
+    downloadFile(remotePath: string, localPath: string, timeout?: number): Promise<void>;
+    downloadFileStream(remotePath: string): Promise<Readable>;
+    /** Several files; a file that fails carries `error` instead of `result`. */
+    downloadFiles(files: FileDownloadRequest[]): Promise<FileDownloadResponse[]>;
+    /** Lines matching `pattern` (a grep pattern) in files under `path`. */
+    findFiles(path: string, pattern: string): Promise<Match[]>;
+    getFileDetails(path: string): Promise<FileInfo>;
+    listFiles(path: string, options?: {
+        depth?: number;
+    }): Promise<FileInfo[]>;
+    moveFiles(source: string, destination: string): Promise<void>;
+    /** Replaces every occurrence of `pattern` (plain text) in each file. */
+    replaceInFiles(files: string[], pattern: string, newValue: string): Promise<ReplaceResult[]>;
+    /** Paths under `path` matching a glob such as `*.py`. */
+    searchFiles(path: string, pattern: string): Promise<SearchFilesResponse>;
+    setFilePermissions(path: string, permissions: FilePermissionsParams): Promise<void>;
+    /** Writes a file (from bytes, or from a local path), making its
+     * directories and replacing one that exists. */
+    uploadFile(file: Buffer, remotePath: string, timeout?: number): Promise<void>;
+    uploadFile(localPath: string, remotePath: string, timeout?: number): Promise<void>;
+    uploadFileStream(source: UploadSource, remotePath: string): Promise<void>;
+    uploadFiles(files: FileUpload[]): Promise<void>;
+}

package/dist/daytona/filesystem.js

@@ -0,0 +1,206 @@
+import { resolvePath } from "./context.js";
+import { DaytonaError, DaytonaFileNotFoundError, guard } from "./errors.js";
+const PERMISSIONS = ["---", "--x", "-w-", "-wx", "r--", "r-x", "rw-", "rwx"];
+function fileInfo(entry) {
+    const bits = (parseInt(entry.mode, 8) || 0) & 0o777;
+    const kind = entry.type === "directory" ? "d" : entry.type === "symlink" ? "l" : "-";
+    return {
+        name: entry.name,
+        isDir: entry.type === "directory",
+        size: entry.size,
+        modTime: entry.modifiedAt,
+        mode: `${kind}${PERMISSIONS[(bits >> 6) & 7]}${PERMISSIONS[(bits >> 3) & 7]}${PERMISSIONS[bits & 7]}`,
+        permissions: `0${bits.toString(8).padStart(3, "0")}`,
+        owner: "",
+        group: "",
+    };
+}
+async function bytesOf(source) {
+    if (typeof source === "string") {
+        const { readFile } = await import("node:fs/promises");
+        return readFile(source);
+    }
+    if (source instanceof Uint8Array)
+        return source;
+    if (typeof source.getReader === "function")
+        return new Uint8Array(await new Response(source).arrayBuffer());
+    const chunks = [];
+    for await (const chunk of source)
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : Buffer.from(chunk));
+    return Buffer.concat(chunks);
+}
+/** `sandbox.fs`: Daytona's file calls over Runtime's files API. Relative
+ * paths resolve from the working directory, /workspace on Runtime. */
+export class FileSystem {
+    #ctx;
+    constructor(ctx) {
+        this.#ctx = ctx;
+    }
+    async #path(path) {
+        await this.#ctx.ensureHome(path);
+        return resolvePath(path);
+    }
+    async #files() {
+        return (await this.#ctx.live()).files;
+    }
+    async #run(argv) {
+        const runtime = await this.#ctx.live();
+        const result = await guard("sandbox", () => runtime.exec(argv));
+        if (result.exitCode !== 0) {
+            const message = result.stderr.trim() || `${argv[0]} exited with ${result.exitCode}`;
+            if (/No such file or directory/.test(message))
+                throw new DaytonaFileNotFoundError(message, 404);
+            throw new DaytonaError(message, 400);
+        }
+        return result.stdout;
+    }
+    /** Makes a directory and its parents, with `mode` (such as "755"). */
+    async createFolder(path, mode) {
+        const target = await this.#path(path);
+        await this.#run(["mkdir", "-p", "-m", mode, "--", target]);
+    }
+    async deleteFile(path, recursive = false) {
+        const target = await this.#path(path);
+        const files = await this.#files();
+        const removed = await guard("file", () => files.remove(target, { recursive }));
+        if (!removed)
+            throw new DaytonaFileNotFoundError(`${target} does not exist.`, 404);
+    }
+    async downloadFile(remotePath, localOrTimeout) {
+        const target = await this.#path(remotePath);
+        const files = await this.#files();
+        const bytes = Buffer.from(await guard("file", () => files.read(target)));
+        if (typeof localOrTimeout !== "string")
+            return bytes;
+        const { mkdir, writeFile } = await import("node:fs/promises");
+        const paths = await import("node:path");
+        await mkdir(paths.dirname(localOrTimeout), { recursive: true });
+        await writeFile(localOrTimeout, bytes);
+    }
+    async downloadFileStream(remotePath) {
+        const { Readable } = await import("node:stream");
+        return Readable.from([await this.downloadFile(remotePath)]);
+    }
+    /** Several files; a file that fails carries `error` instead of `result`. */
+    async downloadFiles(files) {
+        const out = [];
+        for (const file of files) {
+            try {
+                if (file.destination) {
+                    await this.downloadFile(file.source, file.destination);
+                    out.push({ source: file.source, result: file.destination });
+                }
+                else
+                    out.push({ source: file.source, result: await this.downloadFile(file.source) });
+            }
+            catch (error) {
+                const failure = error;
+                out.push({
+                    source: file.source,
+                    error: failure.message,
+                    errorDetails: {
+                        message: failure.message,
+                        ...(failure.statusCode ? { statusCode: failure.statusCode } : {}),
+                        ...(failure.code ? { code: failure.code } : {}),
+                    },
+                });
+            }
+        }
+        return out;
+    }
+    /** Lines matching `pattern` (a grep pattern) in files under `path`. */
+    async findFiles(path, pattern) {
+        const target = await this.#path(path);
+        const runtime = await this.#ctx.live();
+        const result = await guard("sandbox", () => runtime.exec(["grep", "-rnI", "--", pattern, target]));
+        if (result.exitCode !== 0 && result.exitCode !== 1)
+            throw new DaytonaError(result.stderr.trim() || "grep failed", 400);
+        return result.stdout
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => {
+            const match = /^(.*?):(\d+):(.*)$/.exec(line);
+            return match
+                ? { file: match[1], line: Number(match[2]), content: match[3] }
+                : { file: line, line: 0, content: "" };
+        });
+    }
+    async getFileDetails(path) {
+        const target = await this.#path(path);
+        const files = await this.#files();
+        const found = await guard("file", () => files.stat(target));
+        if (!found.exists)
+            throw new DaytonaFileNotFoundError(`${target} does not exist.`, 404);
+        return fileInfo(found);
+    }
+    async listFiles(path, options = {}) {
+        const target = await this.#path(path);
+        const files = await this.#files();
+        const entries = await guard("file", () => files.list(target, { depth: options.depth ?? 1, hidden: true }));
+        return entries.map(fileInfo);
+    }
+    async moveFiles(source, destination) {
+        const from = await this.#path(source);
+        const to = await this.#path(destination);
+        const files = await this.#files();
+        await guard("file", () => files.rename(from, to, { overwrite: true }));
+    }
+    /** Replaces every occurrence of `pattern` (plain text) in each file. */
+    async replaceInFiles(files, pattern, newValue) {
+        const api = await this.#files();
+        const results = [];
+        for (const file of files) {
+            const target = await this.#path(file);
+            try {
+                const text = new TextDecoder().decode(await guard("file", () => api.read(target)));
+                await guard("file", () => api.write(target, text.split(pattern).join(newValue)));
+                results.push({ file, success: true });
+            }
+            catch (error) {
+                results.push({ file, success: false, error: error.message });
+            }
+        }
+        return results;
+    }
+    /** Paths under `path` matching a glob such as `*.py`. */
+    async searchFiles(path, pattern) {
+        const target = await this.#path(path);
+        const files = await this.#files();
+        const glob = pattern.includes("/") || pattern.startsWith("**") ? pattern : `**/${pattern}`;
+        const entries = await guard("file", () => files.list(target, { glob, hidden: true }));
+        return { files: entries.map((entry) => entry.path) };
+    }
+    async setFilePermissions(path, permissions) {
+        const target = await this.#path(path);
+        if (permissions.mode)
+            await this.#run(["chmod", permissions.mode, "--", target]);
+        if (permissions.owner || permissions.group)
+            await this.#run([
+                "sudo",
+                "chown",
+                `${permissions.owner ?? ""}${permissions.group ? `:${permissions.group}` : ""}`,
+                "--",
+                target,
+            ]);
+    }
+    async uploadFile(source, remotePath) {
+        const target = await this.#path(remotePath);
+        const bytes = await bytesOf(source);
+        const files = await this.#files();
+        await guard("file", () => files.write(target, bytes));
+    }
+    async uploadFileStream(source, remotePath) {
+        const target = await this.#path(remotePath);
+        const bytes = await bytesOf(source);
+        const files = await this.#files();
+        await guard("file", () => files.write(target, bytes));
+    }
+    async uploadFiles(files) {
+        for (const file of files) {
+            const target = await this.#path(file.destination);
+            const bytes = await bytesOf(file.source);
+            const api = await this.#files();
+            await guard("file", () => api.write(target, bytes));
+        }
+    }
+}

package/dist/daytona/git.d.ts

@@ -0,0 +1,33 @@
+import { type SandboxContext } from "./context.js";
+export interface GitStatus {
+    currentBranch: string;
+    ahead?: number;
+    behind?: number;
+    branchPublished?: boolean;
+    fileStatus: {
+        name: string;
+        staging: string;
+        worktree: string;
+        extra: string;
+    }[];
+}
+export interface ListBranchResponse {
+    branches: string[];
+}
+/** `sandbox.git`: Daytona's git calls, run with the git in the sandbox. */
+export declare class Git {
+    #private;
+    constructor(ctx: SandboxContext);
+    clone(url: string, path: string, branch?: string, commitId?: string, username?: string, password?: string): Promise<void>;
+    add(path: string, files: string[]): Promise<void>;
+    branches(path: string): Promise<ListBranchResponse>;
+    createBranch(path: string, name: string): Promise<void>;
+    checkoutBranch(path: string, branch: string): Promise<void>;
+    deleteBranch(path: string, name: string): Promise<void>;
+    commit(path: string, message: string, author: string, email: string, allowEmpty?: boolean): Promise<{
+        sha: string;
+    }>;
+    push(path: string, username?: string, password?: string): Promise<void>;
+    pull(path: string, username?: string, password?: string): Promise<void>;
+    status(path: string): Promise<GitStatus>;
+}

package/dist/daytona/git.js

@@ -0,0 +1,128 @@
+import { resolvePath } from "./context.js";
+import { DaytonaError, DaytonaGitAuthFailedError, DaytonaGitBranchExistsError, DaytonaGitBranchNotFoundError, DaytonaGitMergeConflictError, DaytonaGitPushRejectedError, DaytonaGitRepoNotFoundError, guard, } from "./errors.js";
+/** Credentials reach git through a helper reading the environment, never the
+ * command line or the remote URL. */
+const HELPER = 'credential.helper=!f() { echo "username=$GIT_USER"; echo "password=$GIT_PASS"; }; f';
+function failure(stderr, fallback) {
+    const message = stderr.trim() || fallback;
+    if (/Authentication failed|could not read Username|403/.test(message))
+        return new DaytonaGitAuthFailedError(message, 401);
+    if (/Repository not found|not found|does not appear to be a git repository/i.test(message))
+        return new DaytonaGitRepoNotFoundError(message, 404);
+    if (/already exists/.test(message))
+        return new DaytonaGitBranchExistsError(message, 409);
+    if (/did not match any|not a valid|unknown revision|branch .* not found/i.test(message))
+        return new DaytonaGitBranchNotFoundError(message, 404);
+    if (/rejected|non-fast-forward/.test(message))
+        return new DaytonaGitPushRejectedError(message, 409);
+    if (/CONFLICT|Merge conflict/.test(message))
+        return new DaytonaGitMergeConflictError(message, 409);
+    return new DaytonaError(message, 400);
+}
+/** `sandbox.git`: Daytona's git calls, run with the git in the sandbox. */
+export class Git {
+    #ctx;
+    constructor(ctx) {
+        this.#ctx = ctx;
+    }
+    async #git(args, auth) {
+        const runtime = await this.#ctx.live();
+        const withAuth = auth?.username !== undefined || auth?.password !== undefined;
+        const result = await guard("sandbox", () => runtime.exec(["git", ...(withAuth ? ["-c", HELPER] : []), ...args], {
+            timeoutMs: 600_000,
+            env: {
+                GIT_TERMINAL_PROMPT: "0",
+                ...(withAuth ? { GIT_USER: auth.username ?? "git", GIT_PASS: auth.password ?? "" } : {}),
+            },
+        }));
+        if (result.exitCode !== 0)
+            throw failure(result.stderr, `git ${args[0]} failed`);
+        return result.stdout;
+    }
+    async #repo(path) {
+        await this.#ctx.ensureHome(path);
+        return resolvePath(path);
+    }
+    async clone(url, path, branch, commitId, username, password) {
+        const target = await this.#repo(path);
+        await this.#git(["clone", ...(branch ? ["--branch", branch] : []), "--", url, target], {
+            ...(username !== undefined ? { username } : {}),
+            ...(password !== undefined ? { password } : {}),
+        });
+        if (commitId)
+            await this.#git(["-C", target, "checkout", commitId]);
+    }
+    async add(path, files) {
+        await this.#git(["-C", await this.#repo(path), "add", "--", ...files]);
+    }
+    async branches(path) {
+        const out = await this.#git([
+            "-C",
+            await this.#repo(path),
+            "branch",
+            "--format=%(refname:short)",
+        ]);
+        return { branches: out.split("\n").filter(Boolean) };
+    }
+    async createBranch(path, name) {
+        await this.#git(["-C", await this.#repo(path), "switch", "-c", name]);
+    }
+    async checkoutBranch(path, branch) {
+        await this.#git(["-C", await this.#repo(path), "checkout", branch]);
+    }
+    async deleteBranch(path, name) {
+        await this.#git(["-C", await this.#repo(path), "branch", "-D", name]);
+    }
+    async commit(path, message, author, email, allowEmpty = false) {
+        const repo = await this.#repo(path);
+        await this.#git([
+            "-C",
+            repo,
+            "-c",
+            `user.name=${author}`,
+            "-c",
+            `user.email=${email}`,
+            "commit",
+            "-m",
+            message,
+            ...(allowEmpty ? ["--allow-empty"] : []),
+        ]);
+        return { sha: (await this.#git(["-C", repo, "rev-parse", "HEAD"])).trim() };
+    }
+    async push(path, username, password) {
+        await this.#git(["-C", await this.#repo(path), "push"], {
+            ...(username !== undefined ? { username } : {}),
+            ...(password !== undefined ? { password } : {}),
+        });
+    }
+    async pull(path, username, password) {
+        await this.#git(["-C", await this.#repo(path), "pull"], {
+            ...(username !== undefined ? { username } : {}),
+            ...(password !== undefined ? { password } : {}),
+        });
+    }
+    async status(path) {
+        const out = await this.#git([
+            "-C",
+            await this.#repo(path),
+            "status",
+            "--porcelain=v1",
+            "--branch",
+        ]);
+        const [head = "", ...lines] = out.split("\n");
+        const branch = /^## (?:No commits yet on )?([^.\s]+)(?:\.\.\.(\S+))?(?: \[(.*)\])?/.exec(head);
+        const counts = branch?.[3] ?? "";
+        return {
+            currentBranch: branch?.[1] ?? "",
+            ahead: Number(/ahead (\d+)/.exec(counts)?.[1] ?? 0),
+            behind: Number(/behind (\d+)/.exec(counts)?.[1] ?? 0),
+            branchPublished: Boolean(branch?.[2]),
+            fileStatus: lines.filter(Boolean).map((line) => ({
+                name: line.slice(3),
+                staging: line[0] ?? " ",
+                worktree: line[1] ?? " ",
+                extra: "",
+            })),
+        };
+    }
+}

package/dist/daytona/image.d.ts

@@ -0,0 +1,45 @@
+/** A file of the build context, as Runtime's image builds take it. */
+export type ContextFile = {
+    path: string;
+    content: string;
+    encoding: "base64";
+    mode?: number;
+};
+declare const PYTHON: readonly ["3.9", "3.10", "3.11", "3.12", "3.13"];
+/** Daytona's declarative image, kept as the Dockerfile it stands for and
+ * built as a Runtime image (`runtime.images.build`) when a sandbox or a
+ * snapshot is created from it. Local files go with the build as its context. */
+export declare class Image {
+    #private;
+    private constructor();
+    /** The Dockerfile so far. */
+    get dockerfile(): string;
+    static base(image: string): Image;
+    static debianSlim(pythonVersion?: (typeof PYTHON)[number]): Image;
+    /** A local Dockerfile; files it copies come from its directory. */
+    static fromDockerfile(path: string): Image;
+    pipInstall(packages: string | string[], options?: {
+        indexUrl?: string;
+        extraIndexUrls?: string[];
+        findLinks?: string[];
+        pre?: boolean;
+        extraOptions?: string;
+    }): Image;
+    pipInstallFromRequirements(requirementsTxt: string): Image;
+    pipInstallFromPyproject(): Image;
+    addLocalFile(localPath: string, remotePath: string): Image;
+    addLocalDir(localPath: string, remotePath: string): Image;
+    runCommands(...commands: (string | string[])[]): Image;
+    env(envVars: Record<string, string>): Image;
+    workdir(dirPath: string): Image;
+    entrypoint(entrypointCommands: string[]): Image;
+    cmd(cmd: string[]): Image;
+    dockerfileCommands(dockerfileCommands: string[]): Image;
+    /** The Dockerfile and its context files, read from the local disk. */
+    build(): Promise<{
+        dockerfile: string;
+        files: ContextFile[];
+        name: string;
+    }>;
+}
+export {};