@workbench-ai/workbench 0.0.67 → 0.0.69

package/dist/adapter-command-env.js

@@ -1,80 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const SYSTEM_PATH_ENTRIES = [
-    "/usr/local/sbin",
-    "/usr/local/bin",
-    "/usr/sbin",
-    "/usr/bin",
-    "/sbin",
-    "/bin",
-];
-export function createAdapterCommandEnv(options = {}) {
-    const baseEnv = options.env ?? process.env;
-    const env = {};
-    for (const [key, value] of Object.entries(baseEnv)) {
-        if (typeof value === "string" && !key.startsWith("WORKBENCH_")) {
-            env[key] = value;
-        }
-    }
-    env.PATH = adapterCommandPath({
-        workspaceRoot: options.workspaceRoot,
-        adapterRoot: options.adapterRoot,
-        basePath: baseEnv.PATH,
-    });
-    for (const [key, value] of Object.entries(options.extraEnv ?? {})) {
-        if (value !== undefined) {
-            env[key] = value;
-        }
-    }
-    return env;
-}
-function adapterCommandPath(options) {
-    return uniquePathEntries([
-        path.dirname(process.execPath),
-        ...optionalProjectBinDirs(options.workspaceRoot),
-        ...optionalProjectBinDirs(options.adapterRoot),
-        ...nodeModuleBinDirsForAncestors(process.cwd()),
-        ...nodeModuleBinDirsForAncestors(path.dirname(fileURLToPath(import.meta.url))),
-        ...optionalAncestorBinDirs(options.workspaceRoot),
-        ...optionalAncestorBinDirs(options.adapterRoot),
-        ...SYSTEM_PATH_ENTRIES,
-        ...(options.basePath ? options.basePath.split(path.delimiter) : []),
-    ]).join(path.delimiter);
-}
-function optionalProjectBinDirs(root) {
-    return root
-        ? [
-            path.join(root, "node_modules", ".bin"),
-            path.join(root, "products", "workbench", "node_modules", ".bin"),
-        ]
-        : [];
-}
-function optionalAncestorBinDirs(root) {
-    return root ? nodeModuleBinDirsForAncestors(root) : [];
-}
-function nodeModuleBinDirsForAncestors(start) {
-    const dirs = [];
-    let current = path.resolve(start);
-    for (let depth = 0; depth < 12; depth += 1) {
-        dirs.push(path.join(current, "node_modules", ".bin"));
-        const parent = path.dirname(current);
-        if (parent === current) {
-            break;
-        }
-        current = parent;
-    }
-    return dirs;
-}
-function uniquePathEntries(entries) {
-    const seen = new Set();
-    const output = [];
-    for (const entry of entries) {
-        const trimmed = entry.trim();
-        if (!trimmed || seen.has(trimmed)) {
-            continue;
-        }
-        seen.add(trimmed);
-        output.push(trimmed);
-    }
-    return output;
-}

package/dist/adapter-project.d.ts

@@ -1,29 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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,EAGL,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,CAUjB"}

package/dist/adapter-project.js

@@ -1,332 +0,0 @@
-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 { composeRuntimeDockerfileWithAdapterInstallers, 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/candidate 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) {
-    return composeRuntimeDockerfileWithAdapterInstallers(dockerfile, adapters.map((adapter) => ({
-        id: adapter.manifest.id,
-        source: adapter.source,
-        setup: adapter.manifest.setup,
-        files: adapter.files,
-    })));
-}
-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: "candidate.improve" }] : []),
-        { invocation: spec.run, operation: "candidate.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];
-}
-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, "");
-}
-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

@@ -1,6 +0,0 @@
-import { type WorkbenchProjectStateSource } from "@workbench-ai/workbench-core";
-import { type LocalProjectSource } from "./project-source.js";
-export declare function localBenchmarkFingerprint(project: LocalProjectSource): string;
-export declare function projectStateBenchmarkFingerprint(source: WorkbenchProjectStateSource): string;
-export declare function localCandidateFingerprint(project: LocalProjectSource): string;
-//# sourceMappingURL=benchmark-fingerprint.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"benchmark-fingerprint.d.ts","sourceRoot":"","sources":["../src/benchmark-fingerprint.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,2BAA2B,EACjC,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAE7B,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAW7E;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,2BAA2B,GAAG,MAAM,CAU5F;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAO7E"}

package/dist/benchmark-fingerprint.js

@@ -1,42 +0,0 @@
-import { engineResolveBindingForSpec, workbenchBenchmarkContentFingerprint, workbenchCandidateContentFingerprint, } from "@workbench-ai/workbench-core";
-import { remoteEngineResolveFiles, } from "./project-source.js";
-export function localBenchmarkFingerprint(project) {
-    return workbenchBenchmarkContentFingerprint({
-        sourceYaml: project.specSource,
-        engineResolveFiles: remoteEngineResolveFiles(project).map(toSurfaceFile),
-        engineResolveBinding: engineResolveBindingForSpec(project.spec),
-        adapterFiles: project.adapterFiles.map(toSurfaceFile),
-        adapterManifests: project.adapters.map((adapter) => adapter.manifest),
-        runtimeFiles: project.dockerfileFiles.map(toSurfaceFile),
-        resources: project.spec.environment.resources ?? {},
-        network: project.spec.environment.network?.egress === "open" ? "on" : "off",
-    });
-}
-export function projectStateBenchmarkFingerprint(source) {
-    return workbenchBenchmarkContentFingerprint({
-        sourceYaml: source.source,
-        engineResolveFiles: source.engineResolveFiles,
-        engineResolveBinding: source.engineResolveBinding,
-        adapterFiles: source.adapterFiles,
-        runtimeFiles: source.runtimeFiles,
-        resources: source.resources,
-        network: source.network,
-    });
-}
-export function localCandidateFingerprint(project) {
-    return workbenchCandidateContentFingerprint({
-        sourceYaml: project.specSource,
-        candidateFiles: project.candidateFiles.map(toSurfaceFile),
-        adapterFiles: project.adapterFiles.map(toSurfaceFile),
-        adapterManifests: project.adapters.map((adapter) => adapter.manifest),
-    });
-}
-function toSurfaceFile(file) {
-    return {
-        path: file.path,
-        kind: "kind" in file ? file.kind : file.encoding === "base64" ? "binary" : "text",
-        encoding: file.encoding ?? "utf8",
-        content: file.content,
-        executable: file.executable === true,
-    };
-}

package/dist/command-model.d.ts

@@ -1,5 +0,0 @@
-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 REMOTE_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

@@ -1 +0,0 @@
-{"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;AAiFnF,eAAO,MAAM,SAAS,QAAuB,CAAC;AAsc9C,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAE/D"}