@jackwener/opencli 1.6.9 → 1.7.0

package/dist/src/discovery.js

@@ -1,17 +1,16 @@
 /**
- * CLI discovery: finds YAML/TS CLI definitions and registers them.
+ * CLI discovery: finds TS CLI definitions and registers them.
  *
  * Supports two modes:
  * 1. FAST PATH (manifest): If a pre-compiled cli-manifest.json exists,
- *    registers all YAML commands instantly without runtime YAML parsing.
- *    TS modules are loaded lazily only when their command is executed.
+ *    registers commands instantly. TS modules are loaded lazily only
+ *    when their command is executed.
  * 2. FALLBACK (filesystem scan): Traditional runtime discovery for development.
  */
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import yaml from 'js-yaml';
 import { Strategy, registerCommand } from './registry.js';
 import { getErrorMessage } from './errors.js';
 import { log } from './logger.js';
@@ -24,14 +23,12 @@ export const USER_CLIS_DIR = path.join(USER_OPENCLI_DIR, 'clis');
 export const PLUGINS_DIR = path.join(USER_OPENCLI_DIR, 'plugins');
 /** Matches files that register commands via cli() or lifecycle hooks */
 const PLUGIN_MODULE_PATTERN = /\b(?:cli|onStartup|onBeforeExecute|onAfterExecute)\s*\(/;
-import { parseYamlArgs } from './yaml-schema.js';
 function parseStrategy(rawStrategy, fallback = Strategy.COOKIE) {
     if (!rawStrategy)
         return fallback;
     const key = rawStrategy.toUpperCase();
     return Strategy[key] ?? fallback;
 }
-import { isRecord } from './utils.js';
 const PACKAGE_ROOT = findPackageRoot(fileURLToPath(import.meta.url));
 /**
  * Ensure ~/.opencli/node_modules/@jackwener/opencli symlink exists so that
@@ -140,7 +137,6 @@ export async function discoverClis(...dirs) {
 }
 /**
  * Fast-path: register commands from pre-compiled manifest.
- * YAML pipelines are inlined — zero YAML parsing at runtime.
  * TS modules are deferred — loaded lazily on first execution.
  */
 async function loadFromManifest(manifestPath, clisDir) {
@@ -148,53 +144,30 @@ async function loadFromManifest(manifestPath, clisDir) {
         const raw = await fs.promises.readFile(manifestPath, 'utf-8');
         const manifest = JSON.parse(raw);
         for (const entry of manifest) {
-            if (entry.type === 'yaml') {
-                // YAML pipelines fully inlined in manifest — register directly
-                const strategy = parseStrategy(entry.strategy);
-                const cmd = {
-                    site: entry.site,
-                    name: entry.name,
-                    aliases: entry.aliases,
-                    description: entry.description ?? '',
-                    domain: entry.domain,
-                    strategy,
-                    browser: entry.browser,
-                    args: entry.args ?? [],
-                    columns: entry.columns,
-                    pipeline: entry.pipeline,
-                    timeoutSeconds: entry.timeout,
-                    source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : `manifest:${entry.site}/${entry.name}`,
-                    deprecated: entry.deprecated,
-                    replacedBy: entry.replacedBy,
-                    navigateBefore: entry.navigateBefore,
-                };
-                registerCommand(cmd);
-            }
-            else if (entry.type === 'ts' && entry.modulePath) {
-                // TS adapters: register a lightweight stub.
-                // The actual module is loaded lazily on first executeCommand().
-                const strategy = parseStrategy(entry.strategy ?? 'cookie');
-                const modulePath = path.resolve(clisDir, entry.modulePath);
-                const cmd = {
-                    site: entry.site,
-                    name: entry.name,
-                    aliases: entry.aliases,
-                    description: entry.description ?? '',
-                    domain: entry.domain,
-                    strategy,
-                    browser: entry.browser ?? true,
-                    args: entry.args ?? [],
-                    columns: entry.columns,
-                    timeoutSeconds: entry.timeout,
-                    source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : modulePath,
-                    deprecated: entry.deprecated,
-                    replacedBy: entry.replacedBy,
-                    navigateBefore: entry.navigateBefore,
-                    _lazy: true,
-                    _modulePath: modulePath,
-                };
-                registerCommand(cmd);
-            }
+            if (!entry.modulePath)
+                continue;
+            const strategy = parseStrategy(entry.strategy ?? 'cookie');
+            const modulePath = path.resolve(clisDir, entry.modulePath);
+            const cmd = {
+                site: entry.site,
+                name: entry.name,
+                aliases: entry.aliases,
+                description: entry.description ?? '',
+                domain: entry.domain,
+                strategy,
+                browser: entry.browser ?? true,
+                args: entry.args ?? [],
+                columns: entry.columns,
+                pipeline: entry.pipeline,
+                timeoutSeconds: entry.timeout,
+                source: entry.sourceFile ? path.resolve(clisDir, entry.sourceFile) : modulePath,
+                deprecated: entry.deprecated,
+                replacedBy: entry.replacedBy,
+                navigateBefore: entry.navigateBefore,
+                _lazy: true,
+                _modulePath: modulePath,
+            };
+            registerCommand(cmd);
         }
         return true;
     }
@@ -223,9 +196,10 @@ async function discoverClisFromFs(dir) {
         await Promise.all(files.map(async (file) => {
             const filePath = path.join(siteDir, file);
             if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-                await registerYamlCli(filePath, site);
+                log.warn(`Ignoring YAML adapter ${filePath} — YAML format is no longer supported. Convert to TypeScript using cli() from '@jackwener/opencli/registry'.`);
+                return;
             }
-            else if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
+            if ((file.endsWith('.js') && !file.endsWith('.d.js')) ||
                 (file.endsWith('.ts') && !file.endsWith('.d.ts') && !file.endsWith('.test.ts'))) {
                 if (!(await isCliModule(filePath)))
                     return;
@@ -237,44 +211,6 @@ async function discoverClisFromFs(dir) {
     });
     await Promise.all(sitePromises);
 }
-async function registerYamlCli(filePath, defaultSite) {
-    try {
-        const raw = await fs.promises.readFile(filePath, 'utf-8');
-        const def = yaml.load(raw);
-        if (!isRecord(def))
-            return;
-        const cliDef = def;
-        const site = cliDef.site ?? defaultSite;
-        const name = cliDef.name ?? path.basename(filePath, path.extname(filePath));
-        const strategyStr = cliDef.strategy ?? (cliDef.browser === false ? 'public' : 'cookie');
-        const strategy = parseStrategy(strategyStr);
-        const browser = cliDef.browser ?? (strategy !== Strategy.PUBLIC);
-        const args = parseYamlArgs(cliDef.args);
-        const cmd = {
-            site,
-            name,
-            aliases: isRecord(cliDef) && Array.isArray(cliDef.aliases)
-                ? cliDef.aliases.filter((value) => typeof value === 'string')
-                : undefined,
-            description: cliDef.description ?? '',
-            domain: cliDef.domain,
-            strategy,
-            browser,
-            args,
-            columns: cliDef.columns,
-            pipeline: cliDef.pipeline,
-            timeoutSeconds: cliDef.timeout,
-            source: filePath,
-            deprecated: cliDef.deprecated,
-            replacedBy: cliDef.replacedBy,
-            navigateBefore: cliDef.navigateBefore,
-        };
-        registerCommand(cmd);
-    }
-    catch (err) {
-        log.warn(`Failed to load ${filePath}: ${getErrorMessage(err)}`);
-    }
-}
 /**
  * Discover and register plugins from ~/.opencli/plugins/.
  * Each subdirectory is treated as a plugin (site = directory name).
@@ -296,7 +232,7 @@ export async function discoverPlugins() {
     }));
 }
 /**
- * Flat scan: read yaml/ts files directly in a plugin directory.
+ * Flat scan: read ts/js files directly in a plugin directory.
  * Unlike discoverClisFromFs, this does NOT expect nested site subdirectories.
  */
 async function discoverPluginDir(dir, site) {
@@ -305,9 +241,10 @@ async function discoverPluginDir(dir, site) {
     await Promise.all(files.map(async (file) => {
         const filePath = path.join(dir, file);
         if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-            await registerYamlCli(filePath, site);
+            log.warn(`Ignoring YAML plugin ${filePath} — YAML format is no longer supported. Convert to TypeScript using cli() from '@jackwener/opencli/registry'.`);
+            return;
         }
-        else if (file.endsWith('.js') && !file.endsWith('.d.js')) {
+        if (file.endsWith('.js') && !file.endsWith('.d.js')) {
             if (!(await isCliModule(filePath)))
                 return;
             await import(pathToFileURL(filePath).href).catch((err) => {

package/dist/src/download/index.d.ts

@@ -52,7 +52,7 @@ export declare function ytdlpDownload(url: string, destPath: string, options?: Y
 /**
  * Save document content to file.
  */
-export declare function saveDocument(content: string, destPath: string, format?: 'json' | 'markdown' | 'html' | 'text', metadata?: Record<string, any>): Promise<{
+export declare function saveDocument(content: string, destPath: string, format?: 'json' | 'markdown' | 'html' | 'text', metadata?: Record<string, unknown>): Promise<{
     success: boolean;
     size: number;
     error?: string;

package/dist/src/engine.test.js

@@ -127,8 +127,7 @@ describe('discoverPlugins', () => {
         }
         catch { }
     });
-    it('discovers YAML plugins from ~/.opencli/plugins/', async () => {
-        // Create a simple YAML adapter in the plugins directory
+    it('ignores YAML files in plugin directories (YAML format removed)', async () => {
         await fs.promises.mkdir(testPluginDir, { recursive: true });
         await fs.promises.writeFile(yamlPath, `
 site: __test-plugin__
@@ -136,25 +135,17 @@ name: greeting
 description: Test plugin greeting
 strategy: public
 browser: false
-
-pipeline:
-  - evaluate: "() => [{ message: 'hello from plugin' }]"
-
-columns: [message]
 `);
         await discoverPlugins();
         const registry = getRegistry();
         const cmd = registry.get('__test-plugin__/greeting');
-        expect(cmd).toBeDefined();
-        expect(cmd.site).toBe('__test-plugin__');
-        expect(cmd.name).toBe('greeting');
-        expect(cmd.description).toBe('Test plugin greeting');
+        expect(cmd).toBeUndefined();
     });
     it('handles non-existent plugins directory gracefully', async () => {
         // 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 () => {
+    it('ignores YAML files in symlinked plugin directories (YAML format removed)', 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'), `
@@ -163,17 +154,11 @@ 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');
+        expect(cmd).toBeUndefined();
     });
     it('skips broken plugin symlinks without throwing', async () => {
         await fs.promises.mkdir(PLUGINS_DIR, { recursive: true });

package/dist/src/execution.js

@@ -167,10 +167,14 @@ export async function executeCommand(cmd, rawKwargs, debug = false) {
                     }
                 }
                 try {
-                    return await runWithTimeout(runCommand(cmd, page, kwargs, debug), {
+                    const result = await runWithTimeout(runCommand(cmd, page, kwargs, debug), {
                         timeout: cmd.timeoutSeconds ?? DEFAULT_BROWSER_COMMAND_TIMEOUT,
                         label: fullName(cmd),
                     });
+                    // Adapter commands are one-shot — close the automation window immediately
+                    // instead of waiting for the 30s idle timeout.
+                    await page.closeWindow?.().catch(() => { });
+                    return result;
                 }
                 catch (err) {
                     // Collect diagnostic while page is still alive (before browserSession closes it).

package/dist/src/generate-verified.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Verified adapter generation:
+ * discover → synthesize → candidate-bound probe → single-session verify.
+ *
+ * v1 contract keeps scope narrow:
+ *   - PUBLIC + COOKIE only
+ *   - read-only JSON API surfaces
+ *   - single best candidate only
+ *   - bounded repair: select/itemPath replacement once
+ *
+ * Contract design principles:
+ *   1. machine-readable
+ *   2. explicit + explainable
+ *   3. testable + versioned
+ *   4. taxonomy by skill decision needs (not internal error sources)
+ *   5. early hint / terminal outcome share consistent decision language
+ */
+import { type IBrowserFactory } from './runtime.js';
+import { Strategy } from './registry.js';
+export type Stage = 'explore' | 'cascade' | 'synthesize' | 'verify' | 'fallback';
+export type Confidence = 'high' | 'medium' | 'low';
+export type StopReason = 'no-viable-api-surface' | 'auth-too-complex' | 'no-viable-candidate' | 'execution-environment-unavailable';
+export type EscalationReason = 'empty-result' | 'sparse-fields' | 'non-array-result' | 'unsupported-required-args' | 'timeout' | 'selector-mismatch' | 'verify-inconclusive';
+export type SuggestedAction = 'stop' | 'inspect-with-browser' | 'ask-for-login' | 'ask-for-sample-arg' | 'manual-review';
+export type Reusability = 'verified-artifact' | 'unverified-candidate' | 'not-reusable';
+export type EarlyHintReason = 'api-surface-looks-viable' | 'candidate-ready-for-verify' | 'no-viable-api-surface' | 'auth-too-complex' | 'no-viable-candidate';
+export interface EarlyHint {
+    stage: 'explore' | 'synthesize' | 'cascade';
+    continue: boolean;
+    reason: EarlyHintReason;
+    confidence: Confidence;
+    candidate?: {
+        name: string;
+        command: string;
+        path: string | null;
+        reusability: 'unverified-candidate' | 'not-reusable';
+    };
+    message?: string;
+}
+export type EarlyHintHandler = (hint: EarlyHint) => void;
+type SupportedStrategy = Strategy.PUBLIC | Strategy.COOKIE;
+export interface GenerateStats {
+    endpoint_count: number;
+    api_endpoint_count: number;
+    candidate_count: number;
+    verified: boolean;
+    repair_attempted: boolean;
+    explore_dir: string;
+}
+export interface VerifiedAdapter {
+    site: string;
+    name: string;
+    command: string;
+    strategy: SupportedStrategy;
+    path: string;
+    metadata_path?: string;
+    reusability: 'verified-artifact';
+}
+export interface EscalationContext {
+    stage: Stage;
+    reason: EscalationReason;
+    confidence: Confidence;
+    suggested_action: SuggestedAction;
+    candidate: {
+        name: string;
+        command: string;
+        path: string | null;
+        reusability: Reusability;
+    };
+}
+export type GenerateOutcome = {
+    status: 'success' | 'blocked' | 'needs-human-check';
+    adapter?: VerifiedAdapter;
+    reason?: StopReason;
+    stage?: Stage;
+    confidence?: Confidence;
+    escalation?: EscalationContext;
+    reusability?: Reusability;
+    message?: string;
+    stats: GenerateStats;
+};
+export interface GenerateVerifiedOptions {
+    url: string;
+    BrowserFactory: new () => IBrowserFactory;
+    goal?: string | null;
+    site?: string;
+    waitSeconds?: number;
+    top?: number;
+    workspace?: string;
+    noRegister?: boolean;
+    onEarlyHint?: EarlyHintHandler;
+}
+export interface VerifiedArtifactMetadata {
+    artifact_kind: 'verified';
+    schema_version: 1;
+    source_url: string;
+    goal: string | null;
+    strategy: SupportedStrategy;
+    verified: true;
+    reusable: true;
+    reusability_reason: 'verified-artifact';
+}
+export declare function generateVerifiedFromUrl(opts: GenerateVerifiedOptions): Promise<GenerateOutcome>;
+export declare function renderGenerateVerifiedSummary(result: GenerateOutcome): string;
+export {};