@jackwener/opencli 1.5.0 → 1.5.2

package/dist/discovery.js

@@ -127,22 +127,20 @@ async function discoverClisFromFs(dir) {
         const site = entry.name;
         const siteDir = path.join(dir, site);
         const files = await fs.promises.readdir(siteDir);
-        const filePromises = [];
-        for (const file of files) {
+        await Promise.all(files.map(async (file) => {
             const filePath = path.join(siteDir, file);
             if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                filePromises.push(registerYamlCli(filePath, site));
+                await registerYamlCli(filePath, site);
             }
             else if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
                 (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts'))) {
                 if (!(await isCliModule(filePath)))
-                    continue;
-                filePromises.push(import(pathToFileURL(filePath).href).catch((err) => {
+                    return;
+                await import(pathToFileURL(filePath).href).catch((err) => {
                     log.warn(`Failed to load module ${filePath}: ${getErrorMessage(err)}`);
-                }));
+                });
             }
-        }
-        await Promise.all(filePromises);
+        }));
     });
     await Promise.all(sitePromises);
 }
@@ -194,11 +192,12 @@ export async function discoverPlugins() {
         return;
     }
     const entries = await fs.promises.readdir(PLUGINS_DIR, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isDirectory())
-            continue;
-        await discoverPluginDir(path.join(PLUGINS_DIR, entry.name), entry.name);
-    }
+    await Promise.all(entries.map(async (entry) => {
+        const pluginDir = path.join(PLUGINS_DIR, entry.name);
+        if (!(await isDiscoverablePluginDir(entry, pluginDir)))
+            return;
+        await discoverPluginDir(pluginDir, entry.name);
+    }));
 }
 /**
  * Flat scan: read yaml/ts files directly in a plugin directory.
@@ -207,32 +206,29 @@ export async function discoverPlugins() {
 async function discoverPluginDir(dir, site) {
     const files = await fs.promises.readdir(dir);
     const fileSet = new Set(files);
-    const promises = [];
-    for (const file of files) {
+    await Promise.all(files.map(async (file) => {
         const filePath = path.join(dir, file);
         if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-            promises.push(registerYamlCli(filePath, site));
+            await registerYamlCli(filePath, site);
         }
         else if (file.endsWith('.js') && !file.endsWith('.d.js')) {
             if (!(await isCliModule(filePath)))
-                continue;
-            promises.push(import(pathToFileURL(filePath).href).catch((err) => {
+                return;
+            await import(pathToFileURL(filePath).href).catch((err) => {
                 log.warn(`Plugin ${site}/${file}: ${getErrorMessage(err)}`);
-            }));
+            });
         }
         else if (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts')) {
-            // Skip .ts if a compiled .js sibling exists (production mode can't load .ts)
             const jsFile = file.replace(/\.ts$/, '.js');
+            // Prefer compiled .js — skip the .ts source file
             if (fileSet.has(jsFile))
-                continue;
-            if (!(await isCliModule(filePath)))
-                continue;
-            promises.push(import(pathToFileURL(filePath).href).catch((err) => {
-                log.warn(`Plugin ${site}/${file}: ${getErrorMessage(err)}`);
-            }));
+                return;
+            // No compiled .js found — cannot import raw .ts in production Node.js.
+            // This typically means esbuild transpilation failed during plugin install.
+            log.warn(`Plugin ${site}/${file}: no compiled .js found. ` +
+                `Run "opencli plugin update ${site}" to re-transpile, or install esbuild.`);
         }
-    }
-    await Promise.all(promises);
+    }));
 }
 async function isCliModule(filePath) {
     try {
@@ -244,3 +240,19 @@ async function isCliModule(filePath) {
         return false;
     }
 }
+async function isDiscoverablePluginDir(entry, pluginDir) {
+    if (entry.isDirectory())
+        return true;
+    if (!entry.isSymbolicLink())
+        return false;
+    try {
+        return (await fs.promises.stat(pluginDir)).isDirectory();
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== 'ENOENT' && code !== 'ENOTDIR') {
+            log.warn(`Failed to inspect plugin link ${pluginDir}: ${getErrorMessage(err)}`);
+        }
+        return false;
+    }
+}

package/dist/doctor.d.ts

@@ -1,11 +1,10 @@
 /**
- * opencli doctor — diagnose and fix browser connectivity.
+ * opencli doctor — diagnose browser connectivity.
  *
  * Simplified for the daemon-based architecture. No more token management,
  * MCP path discovery, or config file scanning.
  */
 export type DoctorOptions = {
-    fix?: boolean;
     yes?: boolean;
     live?: boolean;
     sessions?: boolean;

package/dist/doctor.js

@@ -1,5 +1,5 @@
 /**
- * opencli doctor — diagnose and fix browser connectivity.
+ * opencli doctor — diagnose browser connectivity.
  *
  * Simplified for the daemon-based architecture. No more token management,
  * MCP path discovery, or config file scanning.
@@ -58,16 +58,20 @@ export async function runBrowserDoctor(opts = {}) {
     if (status.running && !status.extensionConnected) {
         issues.push('Daemon is running but the Chrome extension is not connected.\n' +
             'Please install the opencli Browser Bridge extension:\n' +
-            '  1. Download from GitHub Releases\n' +
+            '  1. Download from https://github.com/jackwener/opencli/releases\n' +
             '  2. Open chrome://extensions/ → Enable Developer Mode\n' +
             '  3. Click "Load unpacked" → select the extension folder');
     }
     if (connectivity && !connectivity.ok) {
         issues.push(`Browser connectivity test failed: ${connectivity.error ?? 'unknown'}`);
     }
-    if (status.extensionVersion && opts.cliVersion && status.extensionVersion !== opts.cliVersion) {
-        issues.push(`Extension version mismatch: extension v${status.extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
-            '  Download the latest extension from: https://github.com/jackwener/opencli/releases');
+    if (status.extensionVersion && opts.cliVersion) {
+        const extMajor = status.extensionVersion.split('.')[0];
+        const cliMajor = opts.cliVersion.split('.')[0];
+        if (extMajor !== cliMajor) {
+            issues.push(`Extension major version mismatch: extension v${status.extensionVersion} ≠ CLI v${opts.cliVersion}\n` +
+                '  Download the latest extension from: https://github.com/jackwener/opencli/releases');
+        }
     }
     return {
         cliVersion: opts.cliVersion,

package/dist/engine.test.js

@@ -75,11 +75,26 @@ cli({
 describe('discoverPlugins', () => {
     const testPluginDir = path.join(PLUGINS_DIR, '__test-plugin__');
     const yamlPath = path.join(testPluginDir, 'greeting.yaml');
+    const symlinkTargetDir = path.join(os.tmpdir(), '__test-plugin-symlink-target__');
+    const symlinkPluginDir = path.join(PLUGINS_DIR, '__test-plugin-symlink__');
+    const brokenSymlinkDir = path.join(PLUGINS_DIR, '__test-plugin-broken__');
     afterEach(async () => {
         try {
             await fs.promises.rm(testPluginDir, { recursive: true });
         }
         catch { }
+        try {
+            await fs.promises.rm(symlinkPluginDir, { recursive: true, force: true });
+        }
+        catch { }
+        try {
+            await fs.promises.rm(symlinkTargetDir, { recursive: true, force: true });
+        }
+        catch { }
+        try {
+            await fs.promises.rm(brokenSymlinkDir, { recursive: true, force: true });
+        }
+        catch { }
     });
     it('discovers YAML plugins from ~/.opencli/plugins/', async () => {
         // Create a simple YAML adapter in the plugins directory
@@ -108,6 +123,33 @@ columns: [message]
         // discoverPlugins should not throw if ~/.opencli/plugins/ does not exist
         await expect(discoverPlugins()).resolves.not.toThrow();
     });
+    it('discovers YAML plugins from symlinked plugin directories', async () => {
+        await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
+        await fs.promises.mkdir(symlinkTargetDir, { recursive: true });
+        await fs.promises.writeFile(path.join(symlinkTargetDir, 'hello.yaml'), `
+site: __test-plugin-symlink__
+name: hello
+description: Test plugin greeting via symlink
+strategy: public
+browser: false
+
+pipeline:
+  - evaluate: "() => [{ message: 'hello from symlink plugin' }]"
+
+columns: [message]
+`);
+        await fs.promises.symlink(symlinkTargetDir, symlinkPluginDir, 'dir');
+        await discoverPlugins();
+        const cmd = getRegistry().get('__test-plugin-symlink__/hello');
+        expect(cmd).toBeDefined();
+        expect(cmd.description).toBe('Test plugin greeting via symlink');
+    });
+    it('skips broken plugin symlinks without throwing', async () => {
+        await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });
+        await fs.promises.symlink(path.join(os.tmpdir(), '__missing-plugin-target__'), brokenSymlinkDir, 'dir');
+        await expect(discoverPlugins()).resolves.not.toThrow();
+        expect(getRegistry().get('__test-plugin-broken__/hello')).toBeUndefined();
+    });
 });
 describe('executeCommand', () => {
     beforeEach(() => {

package/dist/errors.d.ts

@@ -31,7 +31,7 @@ export declare class AuthRequiredError extends CliError {
     constructor(domain: string, message?: string);
 }
 export declare class TimeoutError extends CliError {
-    constructor(label: string, seconds: number);
+    constructor(label: string, seconds: number, hint?: string);
 }
 export declare class ArgumentError extends CliError {
     constructor(message: string, hint?: string);

package/dist/errors.js

@@ -41,8 +41,8 @@ export class AuthRequiredError extends CliError {
     }
 }
 export class TimeoutError extends CliError {
-    constructor(label, seconds) {
-        super('TIMEOUT', `${label} timed out after ${seconds}s`, 'Try again, or increase timeout with OPENCLI_BROWSER_COMMAND_TIMEOUT env var');
+    constructor(label, seconds, hint) {
+        super('TIMEOUT', `${label} timed out after ${seconds}s`, hint ?? 'Try again, or increase timeout with OPENCLI_BROWSER_COMMAND_TIMEOUT env var');
     }
 }
 export class ArgumentError extends CliError {

package/dist/execution.js

@@ -17,8 +17,6 @@ import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
 import { emitHook } from './hooks.js';
 import { checkDaemonStatus } from './browser/discover.js';
-import { PKG_VERSION } from './version.js';
-import chalk from 'chalk';
 const _loadedModules = new Set();
 export function coerceAndValidateArgs(cmdArgs, kwargs) {
     const result = { ...kwargs };
@@ -110,6 +108,25 @@ function ensureRequiredEnv(cmd) {
         return;
     throw new CommandExecutionError(`Command ${fullName(cmd)} requires environment variable ${missing.name}.`, missing.help ?? `Set ${missing.name} before running ${fullName(cmd)}.`);
 }
+/**
+ * Check if the browser is already on the target domain, avoiding redundant navigation.
+ * Returns true if current page hostname matches the pre-nav URL hostname.
+ */
+async function isAlreadyOnDomain(page, targetUrl) {
+    if (!page.getCurrentUrl)
+        return false;
+    try {
+        const currentUrl = await page.getCurrentUrl();
+        if (!currentUrl)
+            return false;
+        const currentHost = new URL(currentUrl).hostname;
+        const targetHost = new URL(targetUrl).hostname;
+        return currentHost === targetHost;
+    }
+    catch {
+        return false;
+    }
+}
 export async function executeCommand(cmd, rawKwargs, debug = false) {
     let kwargs;
     try {
@@ -142,22 +159,26 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
                     '  2. chrome://extensions → Developer Mode → Load unpacked\n' +
                     '  Then run: opencli doctor');
             }
-            // ── Version mismatch: warn but don't block ──
-            if (status.extensionVersion && status.extensionVersion !== PKG_VERSION) {
-                process.stderr.write(chalk.yellow(`⚠  Extension v${status.extensionVersion} ≠ CLI v${PKG_VERSION} — consider updating the extension.\n`));
-            }
             ensureRequiredEnv(cmd);
             const BrowserFactory = getBrowserFactory();
             result = await browserSession(BrowserFactory, async (page) => {
                 const preNavUrl = resolvePreNav(cmd);
                 if (preNavUrl) {
-                    try {
-                        await page.goto(preNavUrl);
-                        await page.wait(2);
-                    }
-                    catch (err) {
+                    const skip = await isAlreadyOnDomain(page, preNavUrl);
+                    if (skip) {
                         if (debug)
-                            console.error(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
+                            console.error(`[pre-nav] Already on target domain, skipping navigation`);
+                    }
+                    else {
+                        try {
+                            // goto() already includes smart DOM-settle detection (waitForDomStable).
+                            // No additional fixed sleep needed.
+                            await page.goto(preNavUrl);
+                        }
+                        catch (err) {
+                            if (debug)
+                                console.error(`[pre-nav] Failed to navigate to ${preNavUrl}: ${err instanceof Error ? err.message : err}`);
+                        }
                     }
                 }
                 return runWithTimeout(runCommand(cmd, page, kwargs, debug), {
@@ -167,7 +188,18 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
             }, { workspace: `site:${cmd.site}` });
         }
         else {
-            result = await runCommand(cmd, null, kwargs, debug);
+            // Non-browser commands: apply timeout only when explicitly configured.
+            const timeout = cmd.timeoutSeconds;
+            if (timeout !== undefined && timeout > 0) {
+                result = await runWithTimeout(runCommand(cmd, null, kwargs, debug), {
+                    timeout,
+                    label: fullName(cmd),
+                    hint: `Increase the adapter's timeoutSeconds setting (currently ${timeout}s)`,
+                });
+            }
+            else {
+                result = await runCommand(cmd, null, kwargs, debug);
+            }
         }
     }
     catch (err) {

package/dist/execution.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/execution.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from 'vitest';
+import { executeCommand } from './execution.js';
+import { TimeoutError } from './errors.js';
+import { cli, Strategy } from './registry.js';
+import { withTimeoutMs } from './runtime.js';
+describe('executeCommand — non-browser timeout', () => {
+    it('applies timeoutSeconds to non-browser commands', async () => {
+        const cmd = cli({
+            site: 'test-execution',
+            name: 'non-browser-timeout',
+            description: 'test non-browser timeout',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            timeoutSeconds: 0.01,
+            func: () => new Promise(() => { }),
+        });
+        // Sentinel timeout at 200ms — if the inner 10ms timeout fires first,
+        // the error will be a TimeoutError with the command label, not 'sentinel'.
+        const error = await withTimeoutMs(executeCommand(cmd, {}), 200, 'sentinel timeout')
+            .catch((err) => err);
+        expect(error).toBeInstanceOf(TimeoutError);
+        expect(error).toMatchObject({
+            code: 'TIMEOUT',
+            message: 'test-execution/non-browser-timeout timed out after 0.01s',
+        });
+    });
+    it('skips timeout when timeoutSeconds is 0', async () => {
+        const cmd = cli({
+            site: 'test-execution',
+            name: 'non-browser-zero-timeout',
+            description: 'test zero timeout bypasses wrapping',
+            browser: false,
+            strategy: Strategy.PUBLIC,
+            timeoutSeconds: 0,
+            func: () => new Promise(() => { }),
+        });
+        // With timeout guard skipped, the sentinel fires instead.
+        await expect(withTimeoutMs(executeCommand(cmd, {}), 50, 'sentinel timeout')).rejects.toThrow('sentinel timeout');
+    });
+});

package/dist/extension-manifest-regression.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/extension-manifest-regression.test.js

@@ -0,0 +1,12 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { describe, expect, it } from 'vitest';
+describe('extension manifest regression', () => {
+    it('keeps host permissions required by chrome.cookies.getAll', async () => {
+        const manifestPath = path.resolve(process.cwd(), 'extension', 'manifest.json');
+        const raw = await fs.readFile(manifestPath, 'utf8');
+        const manifest = JSON.parse(raw);
+        expect(manifest.permissions).toContain('cookies');
+        expect(manifest.host_permissions).toContain('<all_urls>');
+    });
+});

package/dist/external.js

@@ -12,7 +12,10 @@ function getUserRegistryPath() {
     const home = os.homedir();
     return path.join(home, '.opencli', 'external-clis.yaml');
 }
+let _cachedExternalClis = null;
 export function loadExternalClis() {
+    if (_cachedExternalClis)
+        return _cachedExternalClis;
     const configs = new Map();
     // 1. Load built-in
     const builtinPath = path.resolve(__dirname, 'external-clis.yaml');
@@ -41,7 +44,8 @@ export function loadExternalClis() {
     catch (err) {
         log.warn(`Failed to parse user external-clis.yaml: ${getErrorMessage(err)}`);
     }
-    return Array.from(configs.values()).sort((a, b) => a.name.localeCompare(b.name));
+    _cachedExternalClis = Array.from(configs.values()).sort((a, b) => a.name.localeCompare(b.name));
+    return _cachedExternalClis;
 }
 export function isBinaryInstalled(binary) {
     try {
@@ -200,5 +204,6 @@ export function registerExternalCli(name, opts) {
     }
     const dump = yaml.dump(items, { indent: 2, sortKeys: true });
     fs.writeFileSync(userPath, dump, 'utf8');
+    _cachedExternalClis = null; // Invalidate cache so next load reflects the change
     console.log(chalk.dim(userPath));
 }

package/dist/main.js

@@ -24,6 +24,7 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const BUILTIN_CLIS = path.resolve(__dirname, 'clis');
 const USER_CLIS = path.join(os.homedir(), '.opencli', 'clis');
+// Sequential: plugins must run after built-in discovery so they can override built-in commands.
 await discoverClis(BUILTIN_CLIS, USER_CLIS);
 await discoverPlugins();
 // Register exit hook: notice appears after command output (same as npm/gh/yarn)

package/dist/plugin-scaffold.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Plugin scaffold: generates a ready-to-develop plugin directory.
+ *
+ * Usage: opencli plugin create <name> [--dir <path>]
+ *
+ * Creates:
+ *   <name>/
+ *     opencli-plugin.json   — manifest with name, version, description
+ *     package.json          — ESM package with opencli peer dependency
+ *     hello.yaml            — sample YAML command
+   *     greet.ts              — sample TS command using the current registry API
+ *     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/plugin-scaffold.js

@@ -0,0 +1,142 @@
+/**
+ * Plugin scaffold: generates a ready-to-develop plugin directory.
+ *
+ * Usage: opencli plugin create <name> [--dir <path>]
+ *
+ * Creates:
+ *   <name>/
+ *     opencli-plugin.json   — manifest with name, version, description
+ *     package.json          — ESM package with opencli peer dependency
+ *     hello.yaml            — sample YAML command
+   *     greet.ts              — sample TS command using the current registry API
+ *     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 = [];
+    // opencli-plugin.json
+    const manifest = {
+        name,
+        version: '0.1.0',
+        description: opts.description ?? `An opencli plugin: ${name}`,
+        opencli: `>=${PKG_VERSION}`,
+    };
+    writeFile(targetDir, 'opencli-plugin.json', JSON.stringify(manifest, null, 2) + '\n');
+    files.push('opencli-plugin.json');
+    // package.json
+    const pkg = {
+        name: `opencli-plugin-${name}`,
+        version: '0.1.0',
+        type: 'module',
+        description: opts.description ?? `An opencli plugin: ${name}`,
+        peerDependencies: {
+            '@jackwener/opencli': `>=${PKG_VERSION}`,
+        },
+    };
+    writeFile(targetDir, 'package.json', JSON.stringify(pkg, null, 2) + '\n');
+    files.push('package.json');
+    // hello.yaml — sample YAML command
+    const yamlContent = `# Sample YAML command for ${name}
+# See: https://github.com/jackwener/opencli#yaml-commands
+
+site: ${name}
+name: hello
+description: "A sample YAML command"
+strategy: public
+browser: false
+
+domain: https://httpbin.org
+
+pipeline:
+  - fetch:
+      url: "https://httpbin.org/get?greeting=hello"
+      method: GET
+  - extract:
+      type: json
+      selector: "$.args"
+`;
+    writeFile(targetDir, 'hello.yaml', yamlContent);
+    files.push('hello.yaml');
+    // 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 '@jackwener/opencli/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 (_page, kwargs) => [{ greeting: \`Hello, \${String(kwargs.name ?? 'World')}!\` }],
+});
+`;
+    writeFile(targetDir, 'greet.ts', tsContent);
+    files.push('greet.ts');
+    // README.md
+    const readme = `# opencli-plugin-${name}
+
+${opts.description ?? `An opencli plugin: ${name}`}
+
+## Install
+
+\`\`\`bash
+# From local development directory
+opencli plugin install file://${targetDir}
+
+# From GitHub (after publishing)
+opencli plugin install github:<user>/opencli-plugin-${name}
+\`\`\`
+
+## Commands
+
+| Command | Type | Description |
+|---------|------|-------------|
+| \`${name}/hello\` | YAML | Sample YAML command |
+| \`${name}/greet\` | TypeScript | Sample TS command |
+
+## Development
+
+\`\`\`bash
+# Install locally for development (symlinked, changes reflect immediately)
+opencli plugin install file://${targetDir}
+
+# Verify commands are registered
+opencli list | grep ${name}
+
+# Run a command
+opencli ${name} hello
+opencli ${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/plugin-scaffold.test.d.ts

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