@agentrhq/webcmd 0.1.1 → 0.1.2

package/dist/src/plugin-manifest.test.js

@@ -0,0 +1,179 @@
+/**
+ * Tests for plugin manifest: reading, validating, and compatibility checks.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { _readPluginManifest as readPluginManifest, _isMonorepo as isMonorepo, _getEnabledPlugins as getEnabledPlugins, _parseVersion as parseVersion, _satisfiesRange as satisfiesRange, MANIFEST_FILENAME, } from './plugin-manifest.js';
+// ── readPluginManifest ──────────────────────────────────────────────────────
+describe('readPluginManifest', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'webcmd-manifest-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('returns null when no manifest file exists', () => {
+        expect(readPluginManifest(tmpDir)).toBeNull();
+    });
+    it('returns null for malformed JSON', () => {
+        fs.writeFileSync(path.join(tmpDir, MANIFEST_FILENAME), 'not json {{{');
+        expect(readPluginManifest(tmpDir)).toBeNull();
+    });
+    it('returns null for non-object JSON (array)', () => {
+        fs.writeFileSync(path.join(tmpDir, MANIFEST_FILENAME), '["a","b"]');
+        expect(readPluginManifest(tmpDir)).toBeNull();
+    });
+    it('returns null for non-object JSON (string)', () => {
+        fs.writeFileSync(path.join(tmpDir, MANIFEST_FILENAME), '"hello"');
+        expect(readPluginManifest(tmpDir)).toBeNull();
+    });
+    it('reads a single-plugin manifest', () => {
+        const manifest = {
+            name: 'polymarket',
+            version: '1.2.0',
+            webcmd: '>=1.0.0',
+            description: 'Prediction market analysis',
+        };
+        fs.writeFileSync(path.join(tmpDir, MANIFEST_FILENAME), JSON.stringify(manifest));
+        const result = readPluginManifest(tmpDir);
+        expect(result).toEqual(manifest);
+    });
+    it('reads a monorepo manifest', () => {
+        const manifest = {
+            version: '1.0.0',
+            webcmd: '>=0.9.0',
+            description: 'My plugin collection',
+            plugins: {
+                polymarket: {
+                    path: 'packages/polymarket',
+                    description: 'Prediction market',
+                    version: '1.2.0',
+                },
+                defi: {
+                    path: 'packages/defi',
+                    description: 'DeFi data',
+                    version: '0.8.0',
+                    disabled: true,
+                },
+            },
+        };
+        fs.writeFileSync(path.join(tmpDir, MANIFEST_FILENAME), JSON.stringify(manifest));
+        const result = readPluginManifest(tmpDir);
+        expect(result).toEqual(manifest);
+        expect(result.plugins.polymarket.path).toBe('packages/polymarket');
+        expect(result.plugins.defi.disabled).toBe(true);
+    });
+});
+// ── isMonorepo ──────────────────────────────────────────────────────────────
+describe('isMonorepo', () => {
+    it('returns false for single-plugin manifest', () => {
+        expect(isMonorepo({ name: 'test', version: '1.0.0' })).toBe(false);
+    });
+    it('returns false for empty plugins object', () => {
+        expect(isMonorepo({ plugins: {} })).toBe(false);
+    });
+    it('returns true for manifest with plugins', () => {
+        expect(isMonorepo({
+            plugins: {
+                foo: { path: 'packages/foo' },
+            },
+        })).toBe(true);
+    });
+});
+// ── getEnabledPlugins ───────────────────────────────────────────────────────
+describe('getEnabledPlugins', () => {
+    it('returns empty array for no plugins', () => {
+        expect(getEnabledPlugins({ name: 'test' })).toEqual([]);
+    });
+    it('filters out disabled plugins', () => {
+        const manifest = {
+            plugins: {
+                foo: { path: 'packages/foo' },
+                bar: { path: 'packages/bar', disabled: true },
+                baz: { path: 'packages/baz' },
+            },
+        };
+        const result = getEnabledPlugins(manifest);
+        expect(result).toHaveLength(2);
+        expect(result.map((r) => r.name)).toEqual(['baz', 'foo']); // sorted
+    });
+    it('returns all when none disabled', () => {
+        const manifest = {
+            plugins: {
+                charlie: { path: 'packages/charlie' },
+                alpha: { path: 'packages/alpha' },
+            },
+        };
+        const result = getEnabledPlugins(manifest);
+        expect(result).toHaveLength(2);
+        expect(result[0].name).toBe('alpha');
+        expect(result[1].name).toBe('charlie');
+    });
+});
+// ── parseVersion ────────────────────────────────────────────────────────────
+describe('parseVersion', () => {
+    it('parses standard versions', () => {
+        expect(parseVersion('1.2.3')).toEqual([1, 2, 3]);
+        expect(parseVersion('0.0.0')).toEqual([0, 0, 0]);
+        expect(parseVersion('10.20.30')).toEqual([10, 20, 30]);
+    });
+    it('parses versions with prerelease suffix', () => {
+        expect(parseVersion('1.2.3-beta.1')).toEqual([1, 2, 3]);
+    });
+    it('returns null for invalid versions', () => {
+        expect(parseVersion('abc')).toBeNull();
+        expect(parseVersion('')).toBeNull();
+        expect(parseVersion('1.2')).toBeNull();
+    });
+});
+// ── satisfiesRange ──────────────────────────────────────────────────────────
+describe('satisfiesRange', () => {
+    it('handles >= constraint', () => {
+        expect(satisfiesRange('1.4.1', '>=1.0.0')).toBe(true);
+        expect(satisfiesRange('1.0.0', '>=1.0.0')).toBe(true);
+        expect(satisfiesRange('0.9.9', '>=1.0.0')).toBe(false);
+    });
+    it('handles <= constraint', () => {
+        expect(satisfiesRange('1.0.0', '<=1.0.0')).toBe(true);
+        expect(satisfiesRange('0.9.0', '<=1.0.0')).toBe(true);
+        expect(satisfiesRange('1.0.1', '<=1.0.0')).toBe(false);
+    });
+    it('handles > constraint', () => {
+        expect(satisfiesRange('1.0.1', '>1.0.0')).toBe(true);
+        expect(satisfiesRange('1.0.0', '>1.0.0')).toBe(false);
+    });
+    it('handles < constraint', () => {
+        expect(satisfiesRange('0.9.9', '<1.0.0')).toBe(true);
+        expect(satisfiesRange('1.0.0', '<1.0.0')).toBe(false);
+    });
+    it('handles ^ (caret) constraint', () => {
+        expect(satisfiesRange('1.2.0', '^1.2.0')).toBe(true);
+        expect(satisfiesRange('1.9.9', '^1.2.0')).toBe(true);
+        expect(satisfiesRange('2.0.0', '^1.2.0')).toBe(false);
+        expect(satisfiesRange('1.1.0', '^1.2.0')).toBe(false);
+    });
+    it('handles ~ (tilde) constraint', () => {
+        expect(satisfiesRange('1.2.0', '~1.2.0')).toBe(true);
+        expect(satisfiesRange('1.2.9', '~1.2.0')).toBe(true);
+        expect(satisfiesRange('1.3.0', '~1.2.0')).toBe(false);
+    });
+    it('handles exact match', () => {
+        expect(satisfiesRange('1.2.3', '1.2.3')).toBe(true);
+        expect(satisfiesRange('1.2.4', '1.2.3')).toBe(false);
+    });
+    it('handles compound range (AND)', () => {
+        expect(satisfiesRange('1.5.0', '>=1.0.0 <2.0.0')).toBe(true);
+        expect(satisfiesRange('2.0.0', '>=1.0.0 <2.0.0')).toBe(false);
+        expect(satisfiesRange('0.9.0', '>=1.0.0 <2.0.0')).toBe(false);
+    });
+    it('returns true for empty range', () => {
+        expect(satisfiesRange('1.0.0', '')).toBe(true);
+        expect(satisfiesRange('1.0.0', '  ')).toBe(true);
+    });
+    it('returns true for unparseable version', () => {
+        expect(satisfiesRange('dev', '>=1.0.0')).toBe(true);
+    });
+});

package/dist/src/plugin-scaffold.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Plugin scaffold: generates a ready-to-develop plugin directory.
+ *
+ * Usage: webcmd plugin create <name> [--dir <path>]
+ *
+ * Creates:
+ *   <name>/
+ *     webcmd-plugin.json   — manifest with name, version, description
+ *     package.json          — ESM package with webcmd peer dependency
+ *     hello.ts              — sample pipeline command
+ *     greet.ts              — sample TS command using func()
+ *     README.md             — basic documentation
+ */
+export interface ScaffoldOptions {
+    /** Directory to create the plugin in. Defaults to `./<name>` */
+    dir?: string;
+    /** Plugin description */
+    description?: string;
+}
+export interface ScaffoldResult {
+    name: string;
+    dir: string;
+    files: string[];
+}
+/**
+ * Create a new plugin scaffold directory.
+ */
+export declare function createPluginScaffold(name: string, opts?: ScaffoldOptions): ScaffoldResult;

package/dist/src/plugin-scaffold.js

@@ -0,0 +1,143 @@
+/**
+ * Plugin scaffold: generates a ready-to-develop plugin directory.
+ *
+ * Usage: webcmd plugin create <name> [--dir <path>]
+ *
+ * Creates:
+ *   <name>/
+ *     webcmd-plugin.json   — manifest with name, version, description
+ *     package.json          — ESM package with webcmd peer dependency
+ *     hello.ts              — sample pipeline command
+ *     greet.ts              — sample TS command using func()
+ *     README.md             — basic documentation
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { PKG_VERSION } from './version.js';
+/**
+ * Create a new plugin scaffold directory.
+ */
+export function createPluginScaffold(name, opts = {}) {
+    // Validate name
+    if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+        throw new Error(`Invalid plugin name "${name}". ` +
+            `Plugin names must start with a lowercase letter and contain only lowercase letters, digits, and hyphens.`);
+    }
+    const targetDir = opts.dir
+        ? path.resolve(opts.dir)
+        : path.resolve(name);
+    if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length > 0) {
+        throw new Error(`Directory "${targetDir}" already exists and is not empty.`);
+    }
+    fs.mkdirSync(targetDir, { recursive: true });
+    const files = [];
+    // webcmd-plugin.json
+    const manifest = {
+        name,
+        version: '0.1.0',
+        description: opts.description ?? `A webcmd plugin: ${name}`,
+        webcmd: `>=${PKG_VERSION}`,
+    };
+    writeFile(targetDir, 'webcmd-plugin.json', JSON.stringify(manifest, null, 2) + '\n');
+    files.push('webcmd-plugin.json');
+    // package.json
+    const pkg = {
+        name: `webcmd-plugin-${name}`,
+        version: '0.1.0',
+        type: 'module',
+        description: opts.description ?? `A webcmd plugin: ${name}`,
+        peerDependencies: {
+            '@agentrhq/webcmd': `>=${PKG_VERSION}`,
+        },
+    };
+    writeFile(targetDir, 'package.json', JSON.stringify(pkg, null, 2) + '\n');
+    files.push('package.json');
+    // hello.ts — sample pipeline command
+    const helloContent = `/**
+ * Sample pipeline command for ${name}.
+ * Demonstrates the declarative pipeline API.
+ */
+
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+
+cli({
+  site: '${name}',
+  name: 'hello',
+  description: 'A sample pipeline command',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  columns: ['greeting'],
+  pipeline: [
+    { fetch: { url: 'https://httpbin.org/get?greeting=hello' } },
+    { select: 'args' },
+  ],
+});
+`;
+    writeFile(targetDir, 'hello.ts', helloContent);
+    files.push('hello.ts');
+    // greet.ts — sample TS command using registry API
+    const tsContent = `/**
+ * Sample TypeScript command for ${name}.
+ * Demonstrates the programmatic cli() registration API.
+ */
+
+import { cli, Strategy } from '@agentrhq/webcmd/registry';
+
+cli({
+  site: '${name}',
+  name: 'greet',
+  description: 'Greet someone by name',
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    { name: 'name', positional: true, required: true, help: 'Name to greet' },
+  ],
+  columns: ['greeting'],
+  func: async (kwargs) => [{ greeting: \`Hello, \${String(kwargs.name ?? 'World')}!\` }],
+});
+`;
+    writeFile(targetDir, 'greet.ts', tsContent);
+    files.push('greet.ts');
+    // README.md
+    const readme = `# webcmd-plugin-${name}
+
+${opts.description ?? `A webcmd plugin: ${name}`}
+
+## Install
+
+\`\`\`bash
+# From local development directory
+webcmd plugin install file://${targetDir}
+
+# From GitHub (after publishing)
+webcmd plugin install github:<user>/webcmd-plugin-${name}
+\`\`\`
+
+## Commands
+
+| Command | Type | Description |
+|---------|------|-------------|
+| \`${name}/hello\` | Pipeline | Sample pipeline command |
+| \`${name}/greet\` | TypeScript | Sample TS command with func() |
+
+## Development
+
+\`\`\`bash
+# Install locally for development (symlinked, changes reflect immediately)
+webcmd plugin install file://${targetDir}
+
+# Verify commands are registered
+webcmd list | grep ${name}
+
+# Run a command
+webcmd ${name} hello
+webcmd ${name} greet --name World
+\`\`\`
+`;
+    writeFile(targetDir, 'README.md', readme);
+    files.push('README.md');
+    return { name, dir: targetDir, files };
+}
+function writeFile(dir, name, content) {
+    fs.writeFileSync(path.join(dir, name), content);
+}

package/dist/src/plugin-scaffold.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Tests for plugin scaffold: create new plugin directories.
+ */
+export {};

package/dist/src/plugin-scaffold.test.js

@@ -0,0 +1,83 @@
+/**
+ * Tests for plugin scaffold: create new plugin directories.
+ */
+import { describe, it, expect, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { createPluginScaffold } from './plugin-scaffold.js';
+describe('createPluginScaffold', () => {
+    const createdDirs = [];
+    afterEach(() => {
+        for (const dir of createdDirs) {
+            try {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+            catch { }
+        }
+        createdDirs.length = 0;
+    });
+    it('creates all expected files', () => {
+        const dir = path.join(os.tmpdir(), `webcmd-scaffold-${Date.now()}`);
+        createdDirs.push(dir);
+        const result = createPluginScaffold('my-test', { dir });
+        expect(result.name).toBe('my-test');
+        expect(result.dir).toBe(dir);
+        expect(result.files).toContain('webcmd-plugin.json');
+        expect(result.files).toContain('package.json');
+        expect(result.files).toContain('hello.ts');
+        expect(result.files).toContain('greet.ts');
+        expect(result.files).toContain('README.md');
+        // All files exist
+        for (const f of result.files) {
+            expect(fs.existsSync(path.join(dir, f))).toBe(true);
+        }
+    });
+    it('generates valid webcmd-plugin.json', () => {
+        const dir = path.join(os.tmpdir(), `webcmd-scaffold-${Date.now()}`);
+        createdDirs.push(dir);
+        createPluginScaffold('test-manifest', { dir, description: 'Test desc' });
+        const manifest = JSON.parse(fs.readFileSync(path.join(dir, 'webcmd-plugin.json'), 'utf-8'));
+        expect(manifest.name).toBe('test-manifest');
+        expect(manifest.version).toBe('0.1.0');
+        expect(manifest.description).toBe('Test desc');
+        expect(manifest.webcmd).toMatch(/^>=/);
+    });
+    it('generates ESM package.json', () => {
+        const dir = path.join(os.tmpdir(), `webcmd-scaffold-${Date.now()}`);
+        createdDirs.push(dir);
+        createPluginScaffold('test-pkg', { dir });
+        const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+        expect(pkg.type).toBe('module');
+        expect(pkg.peerDependencies?.['@agentrhq/webcmd']).toBeDefined();
+    });
+    it('generates a TS sample that matches the current plugin API', () => {
+        const dir = path.join(os.tmpdir(), `webcmd-scaffold-${Date.now()}`);
+        createdDirs.push(dir);
+        createPluginScaffold('test-ts', { dir });
+        const tsSample = fs.readFileSync(path.join(dir, 'greet.ts'), 'utf-8');
+        expect(tsSample).toContain(`import { cli, Strategy } from '@agentrhq/webcmd/registry';`);
+        expect(tsSample).toContain(`strategy: Strategy.PUBLIC`);
+        expect(tsSample).toContain(`help: 'Name to greet'`);
+        expect(tsSample).toContain(`func: async (kwargs)`);
+        expect(tsSample).not.toContain('async run(');
+    });
+    it('documents a supported local install flow', () => {
+        const dir = path.join(os.tmpdir(), `webcmd-scaffold-${Date.now()}`);
+        createdDirs.push(dir);
+        createPluginScaffold('test-readme', { dir });
+        const readme = fs.readFileSync(path.join(dir, 'README.md'), 'utf-8');
+        expect(readme).toContain(`webcmd plugin install file://${dir}`);
+    });
+    it('rejects invalid names', () => {
+        expect(() => createPluginScaffold('Bad_Name')).toThrow('Invalid plugin name');
+        expect(() => createPluginScaffold('123start')).toThrow('Invalid plugin name');
+    });
+    it('rejects non-empty directory', () => {
+        const dir = path.join(os.tmpdir(), `webcmd-scaffold-${Date.now()}`);
+        createdDirs.push(dir);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, 'existing.txt'), 'x');
+        expect(() => createPluginScaffold('test', { dir })).toThrow('not empty');
+    });
+});

package/dist/src/plugin.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Plugin management: install, uninstall, and list plugins.
+ *
+ * Plugins live in ~/.webcmd/plugins/<name>/.
+ * Monorepo clones live in ~/.webcmd/monorepos/<repo-name>/.
+ * Install source format: "github:user/repo", "github:user/repo/subplugin",
+ * "https://github.com/user/repo", "file:///local/plugin", or a local directory path.
+ */
+import * as fs from 'node:fs';
+/** Path to the lock file that tracks installed plugin versions. */
+export declare function getLockFilePath(): string;
+/** Monorepo clones directory: ~/.webcmd/monorepos/ */
+export declare function getMonoreposDir(): string;
+export type PluginSourceRecord = {
+    kind: 'git';
+    url: string;
+} | {
+    kind: 'local';
+    path: string;
+} | {
+    kind: 'monorepo';
+    url: string;
+    repoName: string;
+    subPath: string;
+};
+export interface LockEntry {
+    source: PluginSourceRecord;
+    commitHash: string;
+    installedAt: string;
+    updatedAt?: string;
+}
+export interface PluginInfo {
+    name: string;
+    path: string;
+    commands: string[];
+    source?: string;
+    version?: string;
+    installedAt?: string;
+    /** If from a monorepo, the monorepo name. */
+    monorepoName?: string;
+    /** Description from webcmd-plugin.json. */
+    description?: string;
+}
+interface ParsedSource {
+    type: 'git' | 'local';
+    name: string;
+    subPlugin?: string;
+    cloneUrl?: string;
+    localPath?: string;
+}
+declare function isLocalPluginSource(source?: string): boolean;
+declare function toStoredPluginSource(source: PluginSourceRecord): string;
+declare function toLocalPluginSource(pluginDir: string): string;
+declare function resolvePluginSource(lockEntry: LockEntry | undefined, pluginDir: string): PluginSourceRecord | undefined;
+declare function resolveStoredPluginSource(lockEntry: LockEntry | undefined, pluginDir: string): string | undefined;
+/**
+ * Move a directory, with EXDEV fallback.
+ * fs.renameSync fails when source and destination are on different
+ * filesystems (e.g. /tmp → ~/.webcmd). In that case we copy then remove.
+ */
+type MoveDirFsOps = Pick<typeof fs, 'renameSync' | 'cpSync' | 'rmSync'>;
+declare function moveDir(src: string, dest: string, fsOps?: MoveDirFsOps): void;
+export interface ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+declare function readLockFileWithWriter(writeLock?: (lock: Record<string, LockEntry>) => void): Record<string, LockEntry>;
+export declare function readLockFile(): Record<string, LockEntry>;
+type WriteLockFileFsOps = Pick<typeof fs, 'mkdirSync' | 'writeFileSync' | 'renameSync' | 'rmSync'>;
+declare function writeLockFileWithFs(lock: Record<string, LockEntry>, fsOps?: WriteLockFileFsOps): void;
+export declare function writeLockFile(lock: Record<string, LockEntry>): void;
+/** Get the HEAD commit hash of a git repo directory. */
+export declare function getCommitHash(dir: string): string | undefined;
+/**
+ * Validate that a downloaded plugin directory is a structurally valid plugin.
+ * Checks for at least one command file (.ts, .js) and a valid
+ * package.json if it contains .ts files.
+ */
+export declare function validatePluginStructure(pluginDir: string): ValidationResult;
+declare function installDependencies(dir: string): void;
+/**
+ * Monorepo lifecycle: install shared deps at repo root, then install and finalize each sub-plugin.
+ *
+ * The root install covers monorepos that use npm workspaces to hoist dependencies.
+ * For monorepos that do NOT use workspaces, sub-plugins may declare their own
+ * production dependencies in their package.json.  We install those per sub-plugin
+ * so that runtime imports (e.g. `undici`) can be resolved from the sub-plugin
+ * directory.  When the root already satisfies all deps this is a fast no-op.
+ */
+declare function postInstallMonorepoLifecycle(repoDir: string, pluginDirs: string[]): void;
+/**
+ * Install a plugin from a source.
+ * Supports:
+ *   "github:user/repo"            — single plugin or full monorepo
+ *   "github:user/repo/subplugin"  — specific sub-plugin from a monorepo
+ *   "https://github.com/user/repo"
+ *   "file:///absolute/path"       — local plugin directory (symlinked)
+ *   "/absolute/path"              — local plugin directory (symlinked)
+ *
+ * Returns the installed plugin name(s).
+ */
+export declare function installPlugin(source: string): string | string[];
+/**
+ * Install a local plugin by creating a symlink.
+ * Used for plugin development: the source directory is symlinked into
+ * the plugins dir so changes are reflected immediately.
+ */
+declare function installLocalPlugin(localPath: string, name: string): string;
+/**
+ * Uninstall a plugin by name.
+ * For monorepo sub-plugins: removes symlink and cleans up the monorepo
+ * directory when no more sub-plugins reference it.
+ */
+export declare function uninstallPlugin(name: string): void;
+/** Synchronous check if a path is a symlink. */
+declare function isSymlinkSync(p: string): boolean;
+/**
+ * Update a plugin by name (git pull + re-install lifecycle).
+ * For monorepo sub-plugins: pulls the monorepo root and re-runs lifecycle
+ * for all sub-plugins from the same monorepo.
+ */
+export declare function updatePlugin(name: string): void;
+export interface UpdateResult {
+    name: string;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Update all installed plugins.
+ * Continues even if individual plugin updates fail.
+ */
+export declare function updateAllPlugins(): UpdateResult[];
+/**
+ * List all installed plugins.
+ * Reads webcmd-plugin.json for description/version when available.
+ */
+export declare function listPlugins(): PluginInfo[];
+/** Parse a plugin source string into clone URL, repo name, and optional sub-plugin. */
+declare function parseSource(source: string): ParsedSource | null;
+declare function ensureHostWebcmdPackageLink(targetLink: string, hostRoot: string): void;
+/**
+ * Resolve the path to the esbuild CLI executable with fallback strategies.
+ */
+export declare function resolveEsbuildBin(): string | null;
+declare function resolveHostWebcmdRoot(startFile?: string): string;
+export { ensureHostWebcmdPackageLink as _ensureHostWebcmdPackageLink, resolveHostWebcmdRoot as _resolveHostWebcmdRoot, resolveEsbuildBin as _resolveEsbuildBin, getCommitHash as _getCommitHash, installDependencies as _installDependencies, parseSource as _parseSource, postInstallMonorepoLifecycle as _postInstallMonorepoLifecycle, readLockFile as _readLockFile, readLockFileWithWriter as _readLockFileWithWriter, updateAllPlugins as _updateAllPlugins, validatePluginStructure as _validatePluginStructure, writeLockFile as _writeLockFile, writeLockFileWithFs as _writeLockFileWithFs, isSymlinkSync as _isSymlinkSync, getMonoreposDir as _getMonoreposDir, installLocalPlugin as _installLocalPlugin, isLocalPluginSource as _isLocalPluginSource, moveDir as _moveDir, resolvePluginSource as _resolvePluginSource, resolveStoredPluginSource as _resolveStoredPluginSource, toStoredPluginSource as _toStoredPluginSource, toLocalPluginSource as _toLocalPluginSource, };