@elizaos/agent 2.0.0-beta.1 → 2.0.11-beta.5

package/services/version-compat.js

@@ -0,0 +1,212 @@
+/**
+ * Plugin ↔ Core version compatibility validation.
+ *
+ * Detects version skew between @elizaos/core and plugins that depend on
+ * specific core exports. This catches the class of bug where plugins on npm
+ * advance past the core version, importing symbols that don't exist yet in
+ * the installed core — causing silent import failures that take down every
+ * model provider.
+ *
+ * @see https://github.com/elizaos/eliza/issues/10
+ */
+/**
+ * Plugins that provide AI model capabilities. If ALL of these fail to load
+ * the agent is completely non-functional — no responses can be generated.
+ */
+export const AI_PROVIDER_PLUGINS = [
+    "@elizaos/plugin-anthropic",
+    "@elizaos/plugin-openai",
+    "@elizaos/plugin-openrouter",
+    "@elizaos/plugin-ollama",
+    "@elizaos/plugin-google-genai",
+    "@elizaos/plugin-groq",
+    "@elizaos/plugin-xai",
+    "@elizaos/plugin-zai",
+    "@elizaos/plugin-elizacloud",
+    "@elizaos/plugin-codex-cli",
+];
+/**
+ * Self-declared plugin names (the `name` property on the plugin object) that
+ * correspond to AI provider plugins.  Some plugins use a short internal name
+ * (e.g. "elizaOSCloud") that differs from the npm package name.  The
+ * diagnostic must recognise both forms to avoid false-positive warnings.
+ */
+const AI_PROVIDER_PLUGIN_ALIASES = [
+    "elizaOSCloud",
+    "codex-cli",
+];
+// ---------------------------------------------------------------------------
+// Semver comparison for stable and prerelease tags.
+// ---------------------------------------------------------------------------
+/**
+ * Parse a semver string (including pre-release tags) into a comparable tuple.
+ * Returns null for unparseable versions.
+ *
+ * Examples:
+ *   "2.0.0-beta.0"           → [2, 0, 0, 0]
+ *   "2.0.0-beta.1"           → [2, 0, 0, 1]
+ *   "2.0.0-nightly.20260208" → [2, 0, 0, 20260208]
+ *   "2.0.0"                  → [2, 0, 0, Infinity]  (release beats any pre-release)
+ *
+ * Note: comparisons are only meaningful within the same pre-release tag type
+ * (beta vs beta, nightly vs nightly). Cross-tag comparisons (beta.1 vs rc.1)
+ * compare only the numeric suffix, which may not reflect the intended ordering.
+ * The update checker always compares within the same channel, so this is safe.
+ */
+export function parseSemver(version) {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-(?:beta|rc|nightly)\.(\d+))?$/);
+    if (!match)
+        return null;
+    const major = Number(match[1]);
+    const minor = Number(match[2]);
+    const patch = Number(match[3]);
+    // A release without a pre-release tag sorts after any pre-release.
+    const pre = match[4] !== undefined ? Number(match[4]) : Number.POSITIVE_INFINITY;
+    return [major, minor, patch, pre];
+}
+/**
+ * Compare two semver strings. Returns:
+ *   -1 if a < b
+ *    0 if a === b
+ *    1 if a > b
+ *   null if either version is unparseable.
+ */
+export function compareSemver(a, b) {
+    const pa = parseSemver(a);
+    const pb = parseSemver(b);
+    if (!pa || !pb)
+        return null;
+    for (let i = 0; i < 4; i++) {
+        if (pa[i] < pb[i])
+            return -1;
+        if (pa[i] > pb[i])
+            return 1;
+    }
+    return 0;
+}
+/**
+ * Check if `installed` version satisfies `>= required`.
+ */
+export function versionSatisfies(installed, required) {
+    const cmp = compareSemver(installed, required);
+    return cmp !== null && cmp >= 0;
+}
+// ---------------------------------------------------------------------------
+// Core export probing
+// ---------------------------------------------------------------------------
+/**
+ * Check whether a specific named export exists in `@elizaos/core`.
+ *
+ * This does a live import check — it tests the *actual* installed module,
+ * not a version number lookup.
+ */
+export async function coreExportExists(exportName) {
+    try {
+        const core = (await import("@elizaos/core"));
+        return exportName in core && core[exportName] !== undefined;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND") {
+            return false;
+        }
+        throw err;
+    }
+}
+/**
+ * Read the installed version of a package from its package.json.
+ * Returns null if the package is not installed or the version is unreadable.
+ */
+export async function getInstalledVersion(packageName) {
+    try {
+        // Dynamic import of package.json is not universally supported, so we
+        // use createRequire as a robust fallback for reading metadata.
+        const { createRequire } = await import("node:module");
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve(`${packageName}/package.json`);
+        const { readFileSync } = await import("node:fs");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        return pkg.version;
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "MODULE_NOT_FOUND" ||
+            code === "ERR_MODULE_NOT_FOUND" ||
+            code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+}
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+/**
+ * Validate a single plugin's compatibility with the installed core.
+ */
+export async function validatePluginCompat(pluginName, coreVersion) {
+    const missingExports = [];
+    const pluginVersion = await getInstalledVersion(pluginName);
+    const compatible = missingExports.length === 0;
+    let message = "";
+    if (!compatible) {
+        message =
+            `${pluginName}${pluginVersion ? `@${pluginVersion}` : ""} requires ` +
+                `${missingExports.join(", ")} from @elizaos/core, but the installed ` +
+                `core@${coreVersion} does not export ${missingExports.length === 1 ? "it" : "them"}. ` +
+                `Pin this plugin to a version compatible with core@${coreVersion}, or upgrade core.`;
+    }
+    return {
+        plugin: pluginName,
+        compatible,
+        pluginVersion,
+        coreVersion,
+        missingExports,
+        message,
+    };
+}
+/**
+ * After plugin resolution, check whether at least one AI provider plugin
+ * loaded successfully. If none loaded, return a diagnostic message explaining
+ * whether this is a version-skew issue or a configuration issue.
+ *
+ * @param loadedPluginNames - Names of plugins that loaded successfully.
+ * @param failedPlugins - Names + error strings of plugins that failed to load.
+ */
+export function diagnoseNoAIProvider(loadedPluginNames, failedPlugins) {
+    const isAIProvider = (name) => AI_PROVIDER_PLUGINS.includes(name) ||
+        AI_PROVIDER_PLUGIN_ALIASES.includes(name);
+    const loadedProviders = loadedPluginNames.filter(isAIProvider);
+    // At least one AI provider loaded — no issue.
+    if (loadedProviders.length > 0)
+        return null;
+    if (process.env.ELIZA_LOCAL_LLAMA?.trim() === "1" ||
+        process.env.ELIZA_DEVICE_BRIDGE_ENABLED?.trim() === "1" ||
+        process.env.ELIZA_ALLOW_NO_PROVIDER?.trim() === "1") {
+        return null;
+    }
+    // Check if any AI provider plugins were attempted but failed.
+    const failedProviders = failedPlugins.filter((f) => AI_PROVIDER_PLUGINS.includes(f.name));
+    if (failedProviders.length === 0) {
+        return ("No AI provider plugin was loaded. Set an API key environment variable " +
+            "(e.g. ANTHROPIC_API_KEY, OPENAI_API_KEY, OPENROUTER_API_KEY) or log in " +
+            "to Eliza Cloud (ELIZAOS_CLOUD_API_KEY) to enable at least one model provider.");
+    }
+    // Check for the specific version-skew signature.
+    const versionSkewPlugins = failedProviders.filter((f) => f.error.includes("not found in module") ||
+        f.error.includes("Export named") ||
+        f.error.includes("does not provide an export named"));
+    if (versionSkewPlugins.length > 0) {
+        const names = versionSkewPlugins.map((f) => f.name).join(", ");
+        return (`Version skew detected: ${names} failed to import required symbols from ` +
+            `@elizaos/core. This usually means the plugin version is ahead of the ` +
+            `installed core version. Pin the affected plugins to a version compatible ` +
+            `with your installed @elizaos/core, or upgrade core. ` +
+            `See: https://github.com/elizaos/eliza/issues/10`);
+    }
+    // Generic failure.
+    const details = failedProviders
+        .map((f) => `  ${f.name}: ${f.error}`)
+        .join("\n");
+    return `All AI provider plugins failed to load:\n${details}`;
+}

package/services/vfs-builtin-shell.d.ts

@@ -0,0 +1,17 @@
+interface VfsBuiltinShellRequest {
+    cwdUri?: string;
+    command: string;
+    args?: readonly string[];
+    timeoutMs?: number;
+}
+interface VfsBuiltinShellResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    sandbox: "vfs";
+}
+export declare function isVfsUri(value: unknown): value is string;
+export declare function runVfsBuiltinShell(request: VfsBuiltinShellRequest): Promise<VfsBuiltinShellResult>;
+export {};
+//# sourceMappingURL=vfs-builtin-shell.d.ts.map

package/services/vfs-builtin-shell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfs-builtin-shell.d.ts","sourceRoot":"","sources":["../../src/services/vfs-builtin-shell.ts"],"names":[],"mappings":"AAIA,UAAU,sBAAsB;IAC9B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,qBAAqB;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,KAAK,CAAC;CAChB;AAyBD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,qBAAqB,CAAC,CA0BhC"}

package/services/vfs-builtin-shell.js

@@ -0,0 +1,375 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { createVirtualFilesystemService } from "./virtual-filesystem.js";
+export function isVfsUri(value) {
+    return typeof value === "string" && value.startsWith("vfs://");
+}
+export async function runVfsBuiltinShell(request) {
+    const startedAt = Date.now();
+    const cwd = parseVfsUri(request.cwdUri);
+    const vfs = createVirtualFilesystemService({ projectId: cwd.projectId });
+    await vfs.initialize();
+    const args = [...(request.args ?? [])];
+    try {
+        const result = isShellCommand(request.command) && args[0] === "-c"
+            ? await runScript(vfs, cwd.virtualPath, args.slice(1).join(" "))
+            : await runCommand(vfs, cwd.virtualPath, request.command, args);
+        return {
+            ...result,
+            durationMs: Date.now() - startedAt,
+            sandbox: "vfs",
+        };
+    }
+    catch (error) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: error instanceof Error ? `${error.message}\n` : String(error),
+            durationMs: Date.now() - startedAt,
+            sandbox: "vfs",
+        };
+    }
+}
+function parseVfsUri(uri) {
+    if (!isVfsUri(uri)) {
+        throw new Error("[vfs-shell] cwd must be a vfs:// URI");
+    }
+    const parsed = new URL(uri);
+    const projectId = parsed.hostname.trim();
+    if (!projectId) {
+        throw new Error("[vfs-shell] vfs:// URI is missing a project id");
+    }
+    return {
+        projectId,
+        virtualPath: decodeURIComponent(parsed.pathname || "/"),
+    };
+}
+function isShellCommand(command) {
+    const base = command.split("/").pop();
+    return base === "sh" || base === "bash";
+}
+async function runScript(vfs, cwd, script) {
+    const segments = script
+        .split(/&&|;/)
+        .map((segment) => segment.trim())
+        .filter(Boolean);
+    let stdout = "";
+    let stderr = "";
+    for (const segment of segments) {
+        const result = await runScriptSegment(vfs, cwd, segment);
+        stdout += result.stdout;
+        stderr += result.stderr;
+        if (result.exitCode !== 0) {
+            return { exitCode: result.exitCode, stdout, stderr };
+        }
+    }
+    return { exitCode: 0, stdout, stderr };
+}
+async function runScriptSegment(vfs, cwd, segment) {
+    const redirect = segment.match(/^(.*?)(>>|>)\s*([^\s]+)\s*$/);
+    if (redirect) {
+        const [, before, op, target] = redirect;
+        const result = await runCommandLine(vfs, cwd, before.trim());
+        if (result.exitCode !== 0)
+            return result;
+        const targetPath = resolveVirtualPath(cwd, stripQuotes(target));
+        const existing = op === ">>" ? await vfs.readFile(targetPath).catch(() => "") : "";
+        await vfs.writeFile(targetPath, existing + result.stdout);
+        return { exitCode: 0, stdout: "", stderr: result.stderr };
+    }
+    return runCommandLine(vfs, cwd, segment);
+}
+async function runCommandLine(vfs, cwd, line) {
+    const [command, ...args] = tokenize(line);
+    if (!command)
+        return { exitCode: 0, stdout: "", stderr: "" };
+    return runCommand(vfs, cwd, command, args);
+}
+async function runCommand(vfs, cwd, command, args) {
+    const name = command.split("/").pop() ?? command;
+    if (name === "echo") {
+        return { exitCode: 0, stdout: `${args.join(" ")}\n`, stderr: "" };
+    }
+    if (name === "printf") {
+        return { exitCode: 0, stdout: args.join(" "), stderr: "" };
+    }
+    if (name === "pwd") {
+        return { exitCode: 0, stdout: `${cwd || "/"}\n`, stderr: "" };
+    }
+    if (name === "cat") {
+        let stdout = "";
+        for (const arg of args) {
+            stdout += await vfs.readFile(resolveVirtualPath(cwd, arg));
+        }
+        return { exitCode: 0, stdout, stderr: "" };
+    }
+    if (name === "mkdir") {
+        return mkdir(vfs, cwd, args);
+    }
+    if (name === "rm") {
+        return rm(vfs, cwd, args);
+    }
+    if (name === "ls") {
+        const target = args.find((arg) => !arg.startsWith("-")) ?? ".";
+        const entries = await vfs.list(resolveVirtualPath(cwd, target));
+        return {
+            exitCode: 0,
+            stdout: entries.map((entry) => path.posix.basename(entry.path)).join("\n") +
+                (entries.length ? "\n" : ""),
+            stderr: "",
+        };
+    }
+    if (name === "grep") {
+        return grep(vfs, cwd, args);
+    }
+    if (name === "rg") {
+        return rg(vfs, cwd, args);
+    }
+    return {
+        exitCode: 127,
+        stdout: "",
+        stderr: `[vfs-shell] unsupported command: ${command}\n`,
+    };
+}
+async function mkdir(vfs, cwd, args) {
+    const optionArgs = args.filter((arg) => arg.startsWith("-"));
+    const parents = optionArgs.some((arg) => arg === "-p" || arg.includes("p"));
+    const targets = args.filter((arg) => !arg.startsWith("-"));
+    if (targets.length === 0) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: "mkdir: missing operand\n",
+        };
+    }
+    for (const target of targets) {
+        await mkdirVirtualPath(vfs, resolveVirtualPath(cwd, target), parents);
+    }
+    return { exitCode: 0, stdout: "", stderr: "" };
+}
+async function rm(vfs, cwd, args) {
+    const optionArgs = args.filter((arg) => arg.startsWith("-"));
+    const recursive = optionArgs.some((arg) => arg === "-r" || arg === "-R" || arg === "-rf" || arg === "-fr");
+    const force = optionArgs.some((arg) => arg.includes("f"));
+    const targets = args.filter((arg) => !arg.startsWith("-"));
+    if (targets.length === 0) {
+        return {
+            exitCode: 1,
+            stdout: "",
+            stderr: "rm: missing operand\n",
+        };
+    }
+    for (const target of targets) {
+        try {
+            await vfs.delete(resolveVirtualPath(cwd, target), { recursive });
+        }
+        catch (error) {
+            if (force &&
+                error instanceof Error &&
+                "code" in error &&
+                error.code === "NOT_FOUND") {
+                continue;
+            }
+            throw error;
+        }
+    }
+    return { exitCode: 0, stdout: "", stderr: "" };
+}
+async function grep(vfs, cwd, args) {
+    const parsed = parseSearchArgs(args, {
+        ignoreCase: false,
+        lineNumber: false,
+        filesWithMatches: false,
+        invertMatch: false,
+    });
+    if (!parsed.pattern) {
+        return { exitCode: 2, stdout: "", stderr: "grep: missing pattern\n" };
+    }
+    const targets = await collectSearchTargets(vfs, cwd, parsed.targets);
+    return searchTargets("grep", parsed.pattern, parsed.options, targets);
+}
+async function rg(vfs, cwd, args) {
+    if (args.includes("--files")) {
+        const targets = await collectSearchTargets(vfs, cwd, args.filter((arg) => arg !== "--files" && !arg.startsWith("-")));
+        return {
+            exitCode: 0,
+            stdout: targets.map((target) => target.path).join("\n") +
+                (targets.length ? "\n" : ""),
+            stderr: "",
+        };
+    }
+    const parsed = parseSearchArgs(args, {
+        ignoreCase: false,
+        lineNumber: true,
+        filesWithMatches: false,
+        invertMatch: false,
+    });
+    if (!parsed.pattern) {
+        return { exitCode: 2, stdout: "", stderr: "rg: missing pattern\n" };
+    }
+    const targets = await collectSearchTargets(vfs, cwd, parsed.targets);
+    return searchTargets("rg", parsed.pattern, parsed.options, targets);
+}
+function parseSearchArgs(args, defaults) {
+    const options = { ...defaults };
+    const positionals = [];
+    let endOfOptions = false;
+    for (const arg of args) {
+        if (!endOfOptions && arg === "--") {
+            endOfOptions = true;
+            continue;
+        }
+        if (!endOfOptions && arg.startsWith("--")) {
+            if (arg === "--ignore-case")
+                options.ignoreCase = true;
+            if (arg === "--line-number")
+                options.lineNumber = true;
+            if (arg === "--files-with-matches")
+                options.filesWithMatches = true;
+            if (arg === "--invert-match")
+                options.invertMatch = true;
+            continue;
+        }
+        if (!endOfOptions && arg.startsWith("-") && arg.length > 1) {
+            for (const flag of arg.slice(1)) {
+                if (flag === "i")
+                    options.ignoreCase = true;
+                if (flag === "n")
+                    options.lineNumber = true;
+                if (flag === "l")
+                    options.filesWithMatches = true;
+                if (flag === "v")
+                    options.invertMatch = true;
+            }
+            continue;
+        }
+        positionals.push(arg);
+    }
+    const [pattern = null, ...targets] = positionals;
+    return { options, pattern, targets };
+}
+async function searchTargets(tool, pattern, options, targets) {
+    let matcher;
+    try {
+        matcher = new RegExp(pattern, options.ignoreCase ? "i" : "");
+    }
+    catch (error) {
+        return {
+            exitCode: 2,
+            stdout: "",
+            stderr: `${tool}: ${error instanceof Error ? error.message : String(error)}\n`,
+        };
+    }
+    const lines = [];
+    for (const target of targets) {
+        let fileMatched = false;
+        const contentLines = target.contents.endsWith("\n")
+            ? target.contents.slice(0, -1).split(/\r?\n/)
+            : target.contents.split(/\r?\n/);
+        for (const [index, line] of contentLines.entries()) {
+            const matched = matcher.test(line);
+            const selected = options.invertMatch ? !matched : matched;
+            if (!selected)
+                continue;
+            fileMatched = true;
+            if (options.filesWithMatches)
+                break;
+            lines.push(formatSearchMatch(target.path, index + 1, line, options));
+        }
+        if (options.filesWithMatches && fileMatched) {
+            lines.push(target.path);
+        }
+    }
+    return {
+        exitCode: lines.length > 0 ? 0 : 1,
+        stdout: lines.join("\n") + (lines.length ? "\n" : ""),
+        stderr: "",
+    };
+}
+function formatSearchMatch(filePath, lineNumber, line, options) {
+    if (options.lineNumber)
+        return `${filePath}:${lineNumber}:${line}`;
+    return `${filePath}:${line}`;
+}
+async function collectSearchTargets(vfs, cwd, rawTargets) {
+    const files = await vfs.exportFiles();
+    const targetPaths = rawTargets.length > 0 ? rawTargets : ["."];
+    const resolvedTargets = targetPaths.map((target) => resolveVirtualPath(cwd, target));
+    const targets = [];
+    for (const file of files) {
+        if (!resolvedTargets.some((target) => virtualPathMatchesTarget(file.path, target))) {
+            continue;
+        }
+        targets.push({
+            path: displayVirtualPath(file.path),
+            contents: file.bytes.toString("utf-8"),
+        });
+    }
+    return targets.sort((a, b) => a.path.localeCompare(b.path));
+}
+function virtualPathMatchesTarget(filePath, target) {
+    const normalizedFile = normalizeAbsoluteVirtualPath(filePath);
+    const normalizedTarget = normalizeAbsoluteVirtualPath(target);
+    return (normalizedFile === normalizedTarget ||
+        normalizedFile.startsWith(`${normalizedTarget.replace(/\/$/, "")}/`));
+}
+function displayVirtualPath(virtualPath) {
+    return virtualPath.replace(/^\/+/, "") || ".";
+}
+async function mkdirVirtualPath(vfs, virtualPath, recursive) {
+    const diskPath = vfs.resolveDiskPath(virtualPath);
+    await assertNoExistingSymlinkPath(vfs, diskPath);
+    await fsp.mkdir(diskPath, { recursive, mode: 0o700 });
+}
+async function assertNoExistingSymlinkPath(vfs, diskPath) {
+    const relative = path.relative(vfs.filesRoot, diskPath);
+    if (!relative)
+        return;
+    let current = vfs.filesRoot;
+    for (const segment of relative.split(path.sep)) {
+        current = path.join(current, segment);
+        const stat = await fsp.lstat(current).catch((error) => {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        });
+        if (!stat)
+            return;
+        if (stat.isSymbolicLink()) {
+            throw new Error(`Symlinks are not allowed in the VFS: ${segment}`);
+        }
+        if (!stat.isDirectory()) {
+            throw new Error(`Path is not a directory: ${segment}`);
+        }
+    }
+}
+function resolveVirtualPath(cwd, input) {
+    const cleanInput = stripQuotes(input);
+    if (!cleanInput || cleanInput === ".")
+        return cwd || "/";
+    if (cleanInput.startsWith("/"))
+        return cleanInput;
+    return path.posix.normalize(path.posix.join(cwd || "/", cleanInput));
+}
+function normalizeAbsoluteVirtualPath(input) {
+    const normalized = path.posix.normalize(input.startsWith("/") ? input : `/${input}`);
+    return normalized === "/" ? "/" : normalized.replace(/\/$/, "");
+}
+function tokenize(input) {
+    const tokens = [];
+    const re = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    let match = re.exec(input);
+    while (match) {
+        tokens.push(match[1] ?? match[2] ?? match[3] ?? "");
+        match = re.exec(input);
+    }
+    return tokens;
+}
+function stripQuotes(input) {
+    const value = input ?? "";
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}

package/services/vfs-git.d.ts

@@ -0,0 +1,18 @@
+import type { PostWorkbenchVfsGitRequest } from "@elizaos/shared";
+import type { VirtualFilesystemService } from "./virtual-filesystem.ts";
+export interface VfsGitStatusEntry {
+    filepath: string;
+    head: GitFileState;
+    workdir: GitFileState;
+    stage: GitFileState;
+}
+export type GitFileState = "absent" | "unchanged" | "modified";
+export interface VfsGitService {
+    run(request: PostWorkbenchVfsGitRequest): Promise<unknown>;
+}
+export declare class VfsGitError extends Error {
+    readonly code: "INVALID_GIT_URL" | "INVALID_GIT_PATH" | "MISSING_ARGUMENT" | "SYMLINK_DENIED";
+    constructor(message: string, code: "INVALID_GIT_URL" | "INVALID_GIT_PATH" | "MISSING_ARGUMENT" | "SYMLINK_DENIED");
+}
+export declare function createVfsGitService(vfs: VirtualFilesystemService): VfsGitService;
+//# sourceMappingURL=vfs-git.d.ts.map

package/services/vfs-git.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vfs-git.d.ts","sourceRoot":"","sources":["../../src/services/vfs-git.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAOlE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAExE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,YAAY,CAAC;IACnB,OAAO,EAAE,YAAY,CAAC;IACtB,KAAK,EAAE,YAAY,CAAC;CACrB;AAED,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,WAAW,GAAG,UAAU,CAAC;AAE/D,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC5D;AAED,qBAAa,WAAY,SAAQ,KAAK;aAGlB,IAAI,EAChB,iBAAiB,GACjB,kBAAkB,GAClB,kBAAkB,GAClB,gBAAgB;gBALpB,OAAO,EAAE,MAAM,EACC,IAAI,EAChB,iBAAiB,GACjB,kBAAkB,GAClB,kBAAkB,GAClB,gBAAgB;CAKvB;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,wBAAwB,GAC5B,aAAa,CAEf"}