@workbench-ai/workbench 0.0.46

package/dist/adapter-project.d.ts

@@ -0,0 +1,29 @@
+import { type WorkbenchAdapterManifest } from "@workbench-ai/workbench-protocol";
+import { type resolveWorkbenchResolvedSourceYaml } from "@workbench-ai/workbench-core";
+export declare const WORKBENCH_ADAPTER_MANIFEST_FILE = "workbench.adapter.yaml";
+export interface ResolvedWorkbenchAdapter {
+    source: string;
+    declaredSource: string;
+    kind: "default" | "path" | "npm" | "git";
+    stability: "default" | "local" | "pinned" | "floating";
+    overridesDefault?: boolean;
+    manifest: WorkbenchAdapterManifest;
+    root?: string;
+    files?: WorkbenchAdapterSourceFile[];
+    integrity?: string;
+    contentHash: string;
+    manifestHash: string;
+}
+export interface WorkbenchAdapterSourceFile {
+    path: string;
+    content: string;
+    executable: boolean;
+}
+type GenericSpec = ReturnType<typeof resolveWorkbenchResolvedSourceYaml>;
+export declare function defaultAdapterManifests(): WorkbenchAdapterManifest[];
+export declare function resolveDefaultWorkbenchAdapter(id: string): ResolvedWorkbenchAdapter | null;
+export declare function resolveWorkbenchAdaptersForProject(dir: string, spec: GenericSpec): Promise<ResolvedWorkbenchAdapter[]>;
+export declare function resolveProjectAdapterSource(dir: string, source: string): Promise<ResolvedWorkbenchAdapter>;
+export declare function composeRuntimeDockerfileWithAdapters(dockerfile: string, adapters: readonly ResolvedWorkbenchAdapter[]): Promise<string>;
+export {};
+//# sourceMappingURL=adapter-project.d.ts.map

package/dist/adapter-project.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-project.d.ts","sourceRoot":"","sources":["../src/adapter-project.ts"],"names":[],"mappings":"AAWA,OAAO,EAKL,KAAK,wBAAwB,EAC9B,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAEL,KAAK,kCAAkC,EACxC,MAAM,8BAA8B,CAAC;AAEtC,eAAO,MAAM,+BAA+B,2BAA2B,CAAC;AAIxE,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IACzC,SAAS,EAAE,SAAS,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAC;IACvD,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,EAAE,wBAAwB,CAAC;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,0BAA0B,EAAE,CAAC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,kCAAkC,CAAC,CAAC;AAEzE,wBAAgB,uBAAuB,IAAI,wBAAwB,EAAE,CAEpE;AAED,wBAAgB,8BAA8B,CAAC,EAAE,EAAE,MAAM,GAAG,wBAAwB,GAAG,IAAI,CAG1F;AAED,wBAAsB,kCAAkC,CACtD,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,WAAW,GAChB,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAmDrC;AAED,wBAAsB,2BAA2B,CAC/C,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,wBAAwB,CAAC,CAwBnC;AAED,wBAAsB,oCAAoC,CACxD,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,SAAS,wBAAwB,EAAE,GAC5C,OAAO,CAAC,MAAM,CAAC,CA2BjB"}

package/dist/adapter-project.js

@@ -0,0 +1,363 @@
+import { createHash } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { builtinWorkbenchAdapterManifest, builtinWorkbenchAdapterManifests, } from "@workbench-ai/workbench-built-in-adapters";
+import { assertWorkbenchAdapterOperationSupport, collectWorkbenchAdapterOperationRequirements, parseWorkbenchAdapterManifest, } from "@workbench-ai/workbench-protocol";
+import { engineResolveInvocationForSpec, } from "@workbench-ai/workbench-core";
+export const WORKBENCH_ADAPTER_MANIFEST_FILE = "workbench.adapter.yaml";
+const execFileAsync = promisify(execFile);
+export function defaultAdapterManifests() {
+    return builtinWorkbenchAdapterManifests();
+}
+export function resolveDefaultWorkbenchAdapter(id) {
+    const manifest = builtinWorkbenchAdapterManifest(id);
+    return manifest ? resolvedDefaultAdapter(manifest) : null;
+}
+export async function resolveWorkbenchAdaptersForProject(dir, spec) {
+    const adapters = new Map();
+    for (const id of topLevelAdapterIds(spec)) {
+        const defaultAdapter = resolveDefaultWorkbenchAdapter(id);
+        if (defaultAdapter) {
+            adapters.set(id, defaultAdapter);
+        }
+    }
+    for (const source of spec.adapters) {
+        const adapter = await resolveProjectAdapterSource(dir, source);
+        const existing = adapters.get(adapter.manifest.id);
+        const override = adapterOverridesDefault(adapter);
+        const resolvedAdapter = {
+            ...adapter,
+            ...(override ? { overridesDefault: true } : {}),
+        };
+        if (existing?.kind === "default") {
+            adapters.set(adapter.manifest.id, resolvedAdapter);
+            continue;
+        }
+        if (existing && existing.source !== adapter.source) {
+            throw new Error(`Adapter id ${adapter.manifest.id} is provided by both ${existing.source} and ${adapter.source}. Remove one adapter source.`);
+        }
+        adapters.set(adapter.manifest.id, resolvedAdapter);
+    }
+    let discovered = true;
+    while (discovered) {
+        discovered = false;
+        const manifestById = new Map([...adapters.values()].map((adapter) => [adapter.manifest.id, adapter.manifest]));
+        for (const id of requiredAdapterIds(spec, [...manifestById.values()])) {
+            if (adapters.has(id)) {
+                continue;
+            }
+            const defaultAdapter = resolveDefaultWorkbenchAdapter(id);
+            if (defaultAdapter) {
+                adapters.set(id, defaultAdapter);
+                discovered = true;
+                continue;
+            }
+            throw new Error(`Adapter ${id} is referenced by benchmark/subject/optimizer YAML but is not installed. List its source under adapters in the YAML file that uses it.`);
+        }
+    }
+    assertWorkbenchAdapterOperationSupport(rootAdapterOperationRequirements(spec), [...adapters.values()].map((adapter) => adapter.manifest));
+    return [...adapters.values()].sort((left, right) => left.manifest.id.localeCompare(right.manifest.id));
+}
+export async function resolveProjectAdapterSource(dir, source) {
+    if (source.startsWith("npm:")) {
+        return await resolveNpmAdapterSource(source);
+    }
+    if (source.startsWith("git:")) {
+        return await resolveGitAdapterSource(source);
+    }
+    const isPathSource = source.startsWith(".") || source.startsWith("/") || source.includes("/");
+    if (!isPathSource) {
+        throw new Error(`Adapter source ${source} is not installed locally. Use a benchmark-contained path source, npm: package, or git: URL.`);
+    }
+    const root = path.resolve(dir, source);
+    const relative = path.relative(dir, root);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`Adapter source ${source} is outside the benchmark source root. Copy it into the benchmark source tree and list that benchmark-contained path.`);
+    }
+    return await resolveAdapterFromRoot({
+        declaredSource: source,
+        source: normalizeSourcePath(relative || "."),
+        kind: "path",
+        root,
+    });
+}
+export async function composeRuntimeDockerfileWithAdapters(dockerfile, adapters) {
+    const installAdapters = adapters.filter((adapter) => adapter.manifest.setup.length > 0 || (adapter.files?.length ?? 0) > 0);
+    if (installAdapters.length === 0) {
+        return dockerfile;
+    }
+    const lines = [
+        dockerfile.trimEnd(),
+        "",
+        "# Workbench adapter setup. The benchmark Dockerfile owns task dependencies;",
+        "# adapter manifests own adapter runtime dependencies.",
+        "USER root",
+    ];
+    for (const adapter of installAdapters) {
+        lines.push("");
+        lines.push(`# Adapter: ${adapter.manifest.id} (${adapter.source})`);
+        if ((adapter.files?.length ?? 0) > 0) {
+            lines.push(...adapterSourceDockerfileLines(adapter));
+            lines.push(`WORKDIR /opt/workbench-adapters/${adapter.manifest.id}`);
+        }
+        for (const command of adapter.manifest.setup) {
+            lines.push(`RUN ${command}`);
+        }
+    }
+    lines.push("WORKDIR /workspace", "");
+    return lines.join("\n");
+}
+function resolvedDefaultAdapter(manifest) {
+    const manifestHash = sha256(JSON.stringify(manifest));
+    return {
+        source: `default:${manifest.id}`,
+        declaredSource: `default:${manifest.id}`,
+        kind: "default",
+        stability: "default",
+        manifest: {
+            ...manifest,
+            operations: JSON.parse(JSON.stringify(manifest.operations)),
+            setup: [...manifest.setup],
+            ...(manifest.slots ? { slots: JSON.parse(JSON.stringify(manifest.slots)) } : {}),
+        },
+        manifestHash,
+        contentHash: manifestHash,
+    };
+}
+function adapterOverridesDefault(adapter) {
+    return adapter.kind !== "default" && builtinWorkbenchAdapterManifest(adapter.manifest.id) !== null;
+}
+async function resolveNpmAdapterSource(source) {
+    const specifier = source.slice("npm:".length).trim();
+    if (!specifier) {
+        throw new Error("npm adapter source must include a package specifier.");
+    }
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "workbench-adapter-npm-"));
+    try {
+        const npmCache = path.join(tempRoot, "npm-cache");
+        const npmLogs = path.join(tempRoot, "npm-logs");
+        await fs.mkdir(npmCache, { recursive: true });
+        await fs.mkdir(npmLogs, { recursive: true });
+        const pack = await execFileUtf8("npm", [
+            "pack",
+            specifier,
+            "--json",
+            "--pack-destination",
+            tempRoot,
+        ], {
+            env: {
+                ...process.env,
+                NPM_CONFIG_CACHE: npmCache,
+                NPM_CONFIG_LOGS_DIR: npmLogs,
+            },
+        });
+        const [entry] = JSON.parse(pack.stdout);
+        if (!entry?.name || !entry.version || !entry.filename) {
+            throw new Error(`npm pack ${specifier} did not return package metadata.`);
+        }
+        const tarballPath = path.join(tempRoot, entry.filename);
+        const extractRoot = path.join(tempRoot, "extract");
+        await fs.mkdir(extractRoot, { recursive: true });
+        await execFileUtf8("tar", ["-xzf", tarballPath, "-C", extractRoot]);
+        return await resolveAdapterFromRoot({
+            declaredSource: source,
+            source: `npm:${entry.name}@${entry.version}`,
+            kind: "npm",
+            stability: npmSourceStability(specifier),
+            root: path.join(extractRoot, "package"),
+            integrity: entry.integrity,
+            includeBuildArtifacts: true,
+        });
+    }
+    finally {
+        await fs.rm(tempRoot, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+async function resolveGitAdapterSource(source) {
+    const specifier = source.slice("git:".length).trim();
+    if (!specifier) {
+        throw new Error("git adapter source must include a repository URL.");
+    }
+    const { url, ref } = parseGitSource(specifier);
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "workbench-adapter-git-"));
+    const checkoutRoot = path.join(tempRoot, "checkout");
+    try {
+        await cloneGitAdapter(url, ref, checkoutRoot);
+        const commit = (await execFileUtf8("git", ["-C", checkoutRoot, "rev-parse", "HEAD"])).stdout.trim();
+        return await resolveAdapterFromRoot({
+            declaredSource: source,
+            source: `git:${url}#${commit}`,
+            kind: "git",
+            stability: gitSourceStability(ref),
+            root: checkoutRoot,
+            integrity: commit,
+            includeBuildArtifacts: true,
+        });
+    }
+    finally {
+        await fs.rm(tempRoot, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+async function resolveAdapterFromRoot(args) {
+    const manifestPath = path.join(args.root, WORKBENCH_ADAPTER_MANIFEST_FILE);
+    const manifestSource = await fs.readFile(manifestPath, "utf8");
+    const manifest = parseWorkbenchAdapterManifest(manifestSource, manifestPath);
+    const files = await readAdapterSourceFiles(args.root, {
+        includeBuildArtifacts: args.includeBuildArtifacts === true,
+    });
+    const manifestHash = sha256(manifestSource);
+    const contentHash = sha256(JSON.stringify(files.map((file) => ({
+        path: file.path,
+        executable: file.executable,
+        contentHash: sha256(file.content),
+    }))));
+    return {
+        source: args.source,
+        declaredSource: args.declaredSource ?? args.source,
+        kind: args.kind,
+        stability: args.stability ?? "local",
+        manifest,
+        root: args.root,
+        files,
+        ...(args.integrity ? { integrity: args.integrity } : {}),
+        manifestHash,
+        contentHash,
+    };
+}
+async function cloneGitAdapter(url, ref, checkoutRoot) {
+    if (ref) {
+        try {
+            await execFileUtf8("git", ["clone", "--depth", "1", "--branch", ref, url, checkoutRoot]);
+            return;
+        }
+        catch {
+            await fs.rm(checkoutRoot, { recursive: true, force: true }).catch(() => undefined);
+        }
+    }
+    await execFileUtf8("git", ["clone", "--depth", "1", url, checkoutRoot]);
+    if (ref) {
+        await execFileUtf8("git", ["-C", checkoutRoot, "fetch", "--depth", "1", "origin", ref]);
+        await execFileUtf8("git", ["-C", checkoutRoot, "checkout", "FETCH_HEAD"]);
+    }
+}
+function parseGitSource(specifier) {
+    const hashIndex = specifier.lastIndexOf("#");
+    if (hashIndex < 0) {
+        return { url: specifier, ref: null };
+    }
+    const url = specifier.slice(0, hashIndex);
+    const ref = specifier.slice(hashIndex + 1);
+    if (!url || !ref) {
+        throw new Error(`Invalid git adapter source: git:${specifier}`);
+    }
+    return { url, ref };
+}
+function npmSourceStability(specifier) {
+    return npmSpecifierHasExactVersion(specifier) ? "pinned" : "floating";
+}
+function npmSpecifierHasExactVersion(specifier) {
+    const atIndex = specifier.lastIndexOf("@");
+    if (atIndex <= 0) {
+        return false;
+    }
+    const version = specifier.slice(atIndex + 1);
+    return /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/u.test(version);
+}
+function gitSourceStability(ref) {
+    return ref && /^[0-9a-f]{7,40}$/iu.test(ref) ? "pinned" : "floating";
+}
+function topLevelAdapterIds(spec) {
+    return [...new Set(rootAdapterInvocations(spec).map((invocation) => invocation.use))];
+}
+function rootAdapterOperationRequirements(spec) {
+    return [
+        { invocation: engineResolveInvocationForSpec(spec), operation: "engine.resolve" },
+        { invocation: spec.engineRun, operation: "engine.run" },
+        ...(spec.improve ? [{ invocation: spec.improve, operation: "optimizer.improve" }] : []),
+        { invocation: spec.run, operation: "subject.run" },
+    ];
+}
+function rootAdapterInvocations(spec) {
+    return rootAdapterOperationRequirements(spec).map((requirement) => requirement.invocation);
+}
+function requiredAdapterIds(spec, manifests) {
+    const ids = new Set();
+    for (const requirement of collectWorkbenchAdapterOperationRequirements(rootAdapterOperationRequirements(spec), manifests)) {
+        ids.add(requirement.invocation.use);
+    }
+    return [...ids];
+}
+function adapterSourceDockerfileLines(adapter) {
+    const root = `/opt/workbench-adapters/${adapter.manifest.id}`;
+    const lines = [`RUN mkdir -p ${shellWord(root)}`];
+    for (const file of adapter.files ?? []) {
+        const destination = `${root}/${file.path}`;
+        const encoded = Buffer.from(file.content, "utf8").toString("base64");
+        lines.push(`RUN mkdir -p ${shellWord(path.posix.dirname(destination))} && printf '%s' ${shellWord(encoded)} | base64 -d > ${shellWord(destination)}${file.executable ? ` && chmod 755 ${shellWord(destination)}` : ""}`);
+    }
+    return lines;
+}
+async function readAdapterSourceFiles(root, options = {}) {
+    const files = [];
+    async function visit(relativeDir) {
+        const absoluteDir = path.join(root, relativeDir);
+        const entries = await fs.readdir(absoluteDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === "node_modules" ||
+                entry.name === ".git" ||
+                (!options.includeBuildArtifacts && entry.name === "dist")) {
+                continue;
+            }
+            const relativePath = normalizeSourcePath(path.join(relativeDir, entry.name));
+            const absolutePath = path.join(root, relativePath);
+            if (entry.isDirectory()) {
+                await visit(relativePath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            const content = await fs.readFile(absolutePath, "utf8");
+            const stat = await fs.stat(absolutePath);
+            files.push({
+                path: relativePath,
+                content,
+                executable: Boolean(stat.mode & 0o111),
+            });
+        }
+    }
+    await visit("");
+    return files.sort((left, right) => left.path.localeCompare(right.path));
+}
+function normalizeSourcePath(value) {
+    return value.replace(/\\/gu, "/").replace(/^\.?\//u, "");
+}
+function shellWord(value) {
+    return `'${value.replace(/'/gu, "'\"'\"'")}'`;
+}
+async function execFileUtf8(command, args, options = {}) {
+    try {
+        return await execFileAsync(command, [...args], {
+            encoding: "utf8",
+            ...(options.env ? { env: options.env } : {}),
+            maxBuffer: 20 * 1024 * 1024,
+        });
+    }
+    catch (error) {
+        const record = error;
+        const stderr = typeof record.stderr === "string" ? record.stderr.trim() : "";
+        const stdout = typeof record.stdout === "string" ? record.stdout.trim() : "";
+        throw new Error([
+            `${command} ${args.join(" ")} failed.`,
+            stderr,
+            stdout,
+            record.message,
+        ].filter(Boolean).join("\n"));
+    }
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}

package/dist/benchmark-fingerprint.d.ts

@@ -0,0 +1,6 @@
+import type { SurfaceSnapshotFile } from "@workbench-ai/workbench-core";
+import type { LocalProjectSource } from "./project-source.js";
+export declare function localBenchmarkFingerprint(project: LocalProjectSource): string;
+export declare function localSubjectFingerprint(project: LocalProjectSource): string;
+export declare function benchmarkFingerprintForFiles(files: readonly SurfaceSnapshotFile[]): string;
+//# sourceMappingURL=benchmark-fingerprint.d.ts.map

package/dist/benchmark-fingerprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"benchmark-fingerprint.d.ts","sourceRoot":"","sources":["../src/benchmark-fingerprint.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAExE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAO7E;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAQ3E;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,SAAS,mBAAmB,EAAE,GACpC,MAAM,CAgBR"}

package/dist/benchmark-fingerprint.js

@@ -0,0 +1,101 @@
+import { createHash } from "node:crypto";
+export function localBenchmarkFingerprint(project) {
+    return benchmarkFingerprintForFiles([
+        textFile("benchmark.yaml", project.benchmarkSource),
+        ...prefixFiles(project.engineResolveFiles.map(toSurfaceFile), project.engineResolveFingerprintPath),
+        ...benchmarkDockerfileFiles(project),
+        ...benchmarkAdapterFiles(project),
+    ]);
+}
+export function localSubjectFingerprint(project) {
+    const hash = createHash("sha256");
+    hash.update("workbench-subject-v1\0");
+    hash.update(project.subjectSource);
+    hash.update("\0runner\0");
+    hash.update(JSON.stringify(project.spec.run));
+    hashSurfaceFiles(hash, project.subjectFiles);
+    return hash.digest("hex");
+}
+export function benchmarkFingerprintForFiles(files) {
+    const hash = createHash("sha256");
+    hash.update("workbench-benchmark-fingerprint-v1\0");
+    for (const file of files
+        .map((entry) => ({ ...entry, path: normalizeLocalPath(entry.path) }))
+        .sort((left, right) => left.path.localeCompare(right.path))) {
+        hash.update(file.path);
+        hash.update("\0");
+        hash.update(file.encoding ?? "utf8");
+        hash.update("\0");
+        hash.update(file.executable ? "1" : "0");
+        hash.update("\0");
+        hash.update(file.content);
+        hash.update("\0");
+    }
+    return hash.digest("hex");
+}
+function benchmarkDockerfileFiles(project) {
+    const dockerfilePath = normalizeLocalPath(project.spec.environment.dockerfile);
+    return project.dockerfileFiles.filter((file) => normalizeLocalPath(file.path) === dockerfilePath).map(toSurfaceFile);
+}
+function benchmarkAdapterFiles(project) {
+    const roots = project.benchmarkAdapterSources.map(normalizeLocalPath);
+    const adapterIdRoots = project.benchmarkAdapterIds.map((id) => normalizeLocalPath(`adapters/${id}`));
+    const allRoots = [...roots, ...adapterIdRoots];
+    if (allRoots.length === 0) {
+        return [];
+    }
+    return project.adapterFiles.filter((file) => allRoots.some((root) => isWithinLocalPath(file.path, root))).map(toSurfaceFile);
+}
+function hashSurfaceFiles(hash, files) {
+    for (const file of files.slice().sort((left, right) => left.path.localeCompare(right.path))) {
+        hash.update("\0file\0");
+        hash.update(file.path);
+        hash.update("\0");
+        hash.update(file.encoding ?? "utf8");
+        hash.update("\0");
+        hash.update(file.content);
+        hash.update("\0");
+        hash.update(file.executable ? "1" : "0");
+    }
+}
+function prefixFiles(files, rootPath) {
+    const root = normalizeLocalPath(rootPath);
+    return files.map((file) => {
+        const filePath = normalizeLocalPath(file.path);
+        return {
+            ...file,
+            path: isWithinLocalPath(filePath, root) ? filePath : `${root}/${filePath}`,
+        };
+    });
+}
+function textFile(filePath, content) {
+    return {
+        path: filePath,
+        kind: "text",
+        encoding: "utf8",
+        content,
+        executable: false,
+    };
+}
+function toSurfaceFile(file) {
+    return {
+        path: file.path,
+        kind: "text",
+        encoding: file.encoding ?? "utf8",
+        content: file.content,
+        executable: file.executable ?? false,
+    };
+}
+function isWithinLocalPath(filePath, rootPath) {
+    const normalizedFile = normalizeLocalPath(filePath);
+    const normalizedRoot = normalizeLocalPath(rootPath);
+    return normalizedFile === normalizedRoot ||
+        normalizedFile.startsWith(`${normalizedRoot}/`);
+}
+function normalizeLocalPath(value) {
+    return value
+        .replace(/\\/gu, "/")
+        .replace(/^\/+/u, "")
+        .replace(/\/+/gu, "/")
+        .replace(/^(?:\.\/)+/u, "");
+}

package/dist/command-model.d.ts

@@ -0,0 +1,5 @@
+export declare const LOCAL_DEV_OPEN_LIFECYCLE_NOTE = "Keep this command running while using the local web view; Ctrl-C stops the server and the page will stop working.";
+export declare const HOSTED_WATCH_LIFECYCLE_NOTE: string;
+export declare const rootUsage: string;
+export declare function commandUsage(commandPath: string): string | null;
+//# sourceMappingURL=command-model.d.ts.map

package/dist/command-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-model.d.ts","sourceRoot":"","sources":["../src/command-model.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,6BAA6B,sHAC2E,CAAC;AAOtH,eAAO,MAAM,2BAA2B,QAA0C,CAAC;AAsFnF,eAAO,MAAM,SAAS,QAAuB,CAAC;AAmX9C,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE/D"}