@agentrhq/webcmd 0.1.1 → 0.1.2

package/dist/src/runtime.d.ts

@@ -0,0 +1,47 @@
+import type { IPage } from './types.js';
+import { DEFAULT_BROWSER_COMMAND_TIMEOUT, DEFAULT_BROWSER_CONNECT_TIMEOUT } from './browser/config.js';
+export { DEFAULT_BROWSER_COMMAND_TIMEOUT, DEFAULT_BROWSER_CONNECT_TIMEOUT };
+/**
+ * Returns the appropriate browser factory based on site type.
+ * Uses CDPBridge for registered Electron apps, otherwise BrowserBridge.
+ */
+export declare function getBrowserFactory(site?: string): new () => IBrowserFactory;
+export type BrowserWindowMode = 'foreground' | 'background';
+export type BrowserSurface = 'browser' | 'adapter';
+/**
+ * Timeout with seconds unit. Used for high-level command timeouts.
+ */
+export declare function runWithTimeout<T>(promise: Promise<T>, opts: {
+    timeout: number;
+    label?: string;
+    hint?: string;
+}): Promise<T>;
+/**
+ * Timeout with milliseconds unit. Used for low-level internal timeouts.
+ * Accepts a factory function to create the rejection error, keeping this
+ * utility decoupled from specific error types.
+ */
+export declare function withTimeoutMs<T>(promise: Promise<T>, timeoutMs: number, makeError?: string | (() => Error)): Promise<T>;
+/** Interface for browser factory (BrowserBridge or test mocks) */
+export interface IBrowserFactory {
+    connect(opts?: {
+        timeout?: number;
+        session?: string;
+        cdpEndpoint?: string;
+        contextId?: string;
+        idleTimeout?: number;
+        windowMode?: BrowserWindowMode;
+        surface?: BrowserSurface;
+        siteSession?: 'ephemeral' | 'persistent';
+    }): Promise<IPage>;
+    close(): Promise<void>;
+}
+export declare function browserSession<T>(BrowserFactory: new () => IBrowserFactory, fn: (page: IPage) => Promise<T>, opts?: {
+    session?: string;
+    cdpEndpoint?: string;
+    contextId?: string;
+    idleTimeout?: number;
+    windowMode?: BrowserWindowMode;
+    surface?: BrowserSurface;
+    siteSession?: 'ephemeral' | 'persistent';
+}): Promise<T>;

package/dist/src/runtime.js

@@ -0,0 +1,54 @@
+import { BrowserBridge, CDPBridge } from './browser/index.js';
+import { TimeoutError } from './errors.js';
+import { isElectronApp } from './electron-apps.js';
+import { DEFAULT_BROWSER_COMMAND_TIMEOUT, DEFAULT_BROWSER_CONNECT_TIMEOUT } from './browser/config.js';
+export { DEFAULT_BROWSER_COMMAND_TIMEOUT, DEFAULT_BROWSER_CONNECT_TIMEOUT };
+/**
+ * Returns the appropriate browser factory based on site type.
+ * Uses CDPBridge for registered Electron apps, otherwise BrowserBridge.
+ */
+export function getBrowserFactory(site) {
+    if (site && isElectronApp(site))
+        return CDPBridge;
+    return BrowserBridge;
+}
+/**
+ * Timeout with seconds unit. Used for high-level command timeouts.
+ */
+export async function runWithTimeout(promise, opts) {
+    const label = opts.label ?? 'Operation';
+    return withTimeoutMs(promise, opts.timeout * 1000, () => new TimeoutError(label, opts.timeout, opts.hint));
+}
+/**
+ * Timeout with milliseconds unit. Used for low-level internal timeouts.
+ * Accepts a factory function to create the rejection error, keeping this
+ * utility decoupled from specific error types.
+ */
+export function withTimeoutMs(promise, timeoutMs, makeError = 'Operation timed out') {
+    const reject_ = typeof makeError === 'string'
+        ? () => new Error(makeError)
+        : makeError;
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(reject_()), timeoutMs);
+        promise.then((value) => { clearTimeout(timer); resolve(value); }, (error) => { clearTimeout(timer); reject(error); });
+    });
+}
+export async function browserSession(BrowserFactory, fn, opts = {}) {
+    const browser = new BrowserFactory();
+    try {
+        const page = await browser.connect({
+            timeout: DEFAULT_BROWSER_CONNECT_TIMEOUT,
+            session: opts.session,
+            cdpEndpoint: opts.cdpEndpoint,
+            contextId: opts.contextId,
+            idleTimeout: opts.idleTimeout,
+            windowMode: opts.windowMode,
+            surface: opts.surface,
+            siteSession: opts.siteSession,
+        });
+        return await fn(page);
+    }
+    finally {
+        await browser.close().catch(() => { });
+    }
+}

package/dist/src/scripts/framework.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Injected script for detecting frontend frameworks (Vue, React, Next, Nuxt, etc.)
+ *
+ * Serialized via `.toString()` and evaluated in the page context. Types here are
+ * only for the TS boundary — see scripts/store.ts for the same pattern.
+ */
+export declare function detectFramework(): Record<string, boolean>;

package/dist/src/scripts/framework.js

@@ -0,0 +1,25 @@
+/**
+ * Injected script for detecting frontend frameworks (Vue, React, Next, Nuxt, etc.)
+ *
+ * Serialized via `.toString()` and evaluated in the page context. Types here are
+ * only for the TS boundary — see scripts/store.ts for the same pattern.
+ */
+export function detectFramework() {
+    const r = {};
+    try {
+        const app = document.querySelector('#app');
+        const w = window;
+        r.vue3 = !!(app && app.__vue_app__);
+        r.vue2 = !!(app && app.__vue__);
+        r.react = !!w.__REACT_DEVTOOLS_GLOBAL_HOOK__ || !!document.querySelector('[data-reactroot]');
+        r.nextjs = !!w.__NEXT_DATA__;
+        r.nuxt = !!w.__NUXT__;
+        if (r.vue3 && app?.__vue_app__) {
+            const gp = app.__vue_app__.config?.globalProperties;
+            r.pinia = !!(gp && gp.$pinia);
+            r.vuex = !!(gp && gp.$store);
+        }
+    }
+    catch { }
+    return r;
+}

package/dist/src/scripts/interact.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Injected script for interactive fuzzing (clicking elements to trigger lazy loading)
+ */
+export declare function interactFuzz(): Promise<number>;

package/dist/src/scripts/interact.js

@@ -0,0 +1,20 @@
+/**
+ * Injected script for interactive fuzzing (clicking elements to trigger lazy loading)
+ */
+export async function interactFuzz() {
+    const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+    const clickables = Array.from(document.querySelectorAll('button, [role="button"], [role="tab"], .tab, .btn, a[href="javascript:void(0)"], a[href="#"]')).slice(0, 15); // limit to a small number to avoid endless loops
+    let clicked = 0;
+    for (const el of clickables) {
+        try {
+            const rect = el.getBoundingClientRect();
+            if (rect.width > 0 && rect.height > 0) {
+                el.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true, view: window }));
+                clicked++;
+                await sleep(300); // give it time to trigger network
+            }
+        }
+        catch { }
+    }
+    return clicked;
+}

package/dist/src/scripts/store.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Injected script for discovering Pinia or Vuex stores and their actions/state representations.
+ *
+ * This function is serialized via `.toString()` and evaluated inside the page context,
+ * so the types below only exist at the TS boundary — the runtime shapes are whatever
+ * Pinia/Vuex put on the Vue app. We use narrow structural types for the fields we touch.
+ */
+export declare function discoverStores(): {
+    type: string;
+    id: string;
+    actions: string[];
+    stateKeys: string[];
+}[];

package/dist/src/scripts/store.js

@@ -0,0 +1,48 @@
+/**
+ * Injected script for discovering Pinia or Vuex stores and their actions/state representations.
+ *
+ * This function is serialized via `.toString()` and evaluated inside the page context,
+ * so the types below only exist at the TS boundary — the runtime shapes are whatever
+ * Pinia/Vuex put on the Vue app. We use narrow structural types for the fields we touch.
+ */
+export function discoverStores() {
+    const stores = [];
+    try {
+        const app = document.querySelector('#app');
+        if (!app?.__vue_app__)
+            return stores;
+        const gp = app.__vue_app__.config?.globalProperties;
+        // Pinia stores
+        const pinia = gp?.$pinia;
+        if (pinia?._s) {
+            pinia._s.forEach((store, id) => {
+                const actions = [];
+                const stateKeys = [];
+                for (const k in store) {
+                    try {
+                        if (k.startsWith('$') || k.startsWith('_'))
+                            continue;
+                        if (typeof store[k] === 'function')
+                            actions.push(k);
+                        else
+                            stateKeys.push(k);
+                    }
+                    catch { }
+                }
+                stores.push({ type: 'pinia', id, actions: actions.slice(0, 20), stateKeys: stateKeys.slice(0, 15) });
+            });
+        }
+        // Vuex store modules
+        const vuex = gp?.$store;
+        if (vuex?._modules?.root?._children) {
+            const children = vuex._modules.root._children;
+            for (const [modName, mod] of Object.entries(children)) {
+                const actions = Object.keys(mod._rawModule?.actions ?? {}).slice(0, 20);
+                const stateKeys = Object.keys(mod.state ?? {}).slice(0, 15);
+                stores.push({ type: 'vuex', id: modName, actions, stateKeys });
+            }
+        }
+    }
+    catch { }
+    return stores;
+}

package/dist/src/serialization.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Serialization and formatting helpers for CLI commands and args.
+ *
+ * Used by the `list` command, Commander --help, and build-manifest.
+ * Separated from registry.ts to keep the registry focused on types + registration.
+ */
+import type { Arg, CliCommand } from './registry.js';
+export type SerializedArg = {
+    name: string;
+    type: string;
+    required: boolean;
+    valueRequired: boolean;
+    positional: boolean;
+    choices: string[];
+    default: unknown;
+    help: string;
+};
+/** Stable arg schema — every field is always present (no sparse objects). */
+export declare function serializeArg(a: Arg): SerializedArg;
+/** Full command metadata for structured output (json/yaml). */
+export declare function serializeCommand(cmd: CliCommand): {
+    command: string;
+    site: string;
+    name: string;
+    aliases: string[];
+    description: string;
+    access: import("./registry.js").CommandAccess;
+    strategy: string;
+    browser: boolean;
+    args: SerializedArg[];
+    columns: string[];
+    domain: string | null;
+    example: string;
+    defaultFormat: "table" | "plain" | "json" | "yaml" | "yml" | "md" | "markdown" | "csv" | null;
+    siteSession: import("./registry.js").SiteSessionMode | null;
+};
+/** Human-readable arg summary: `<required> [optional]` style. */
+export declare function formatArgSummary(args: Arg[]): string;
+/** Agent-facing canonical invocation. Adapter authors may override with `example`. */
+export declare function formatCommandExample(cmd: CliCommand): string;
+/** Generate the --help appendix showing registry metadata not exposed by Commander. */
+export declare function formatRegistryHelpText(cmd: CliCommand): string;

package/dist/src/serialization.js

@@ -0,0 +1,103 @@
+/**
+ * Serialization and formatting helpers for CLI commands and args.
+ *
+ * Used by the `list` command, Commander --help, and build-manifest.
+ * Separated from registry.ts to keep the registry focused on types + registration.
+ */
+import { fullName, strategyLabel } from './registry.js';
+import { CLI_COMMAND } from './brand.js';
+/** Stable arg schema — every field is always present (no sparse objects). */
+export function serializeArg(a) {
+    return {
+        name: a.name,
+        type: a.type ?? 'string',
+        required: !!a.required,
+        valueRequired: !!a.valueRequired,
+        positional: !!a.positional,
+        choices: a.choices ?? [],
+        default: a.default ?? null,
+        help: a.help ?? '',
+    };
+}
+/** Full command metadata for structured output (json/yaml). */
+export function serializeCommand(cmd) {
+    return {
+        command: fullName(cmd),
+        site: cmd.site,
+        name: cmd.name,
+        aliases: cmd.aliases ?? [],
+        description: cmd.description,
+        access: cmd.access,
+        strategy: strategyLabel(cmd),
+        browser: !!cmd.browser,
+        args: cmd.args.map(serializeArg),
+        columns: cmd.columns ?? [],
+        domain: cmd.domain ?? null,
+        example: formatCommandExample(cmd),
+        defaultFormat: cmd.defaultFormat ?? null,
+        siteSession: cmd.siteSession ?? null,
+    };
+}
+// ── Formatting ──────────────────────────────────────────────────────────────
+/** Human-readable arg summary: `<required> [optional]` style. */
+export function formatArgSummary(args) {
+    return args
+        .map(a => {
+        if (a.positional)
+            return a.required ? `<${a.name}>` : `[${a.name}]`;
+        return a.required ? `--${a.name}` : `[--${a.name}]`;
+    })
+        .join(' ');
+}
+function summarizeChoices(choices) {
+    if (choices.length <= 4)
+        return choices.join(', ');
+    return `${choices.slice(0, 4).join(', ')}, ... (+${choices.length - 4} more)`;
+}
+function formatValuePlaceholder(name) {
+    return `<${name}>`;
+}
+/** Agent-facing canonical invocation. Adapter authors may override with `example`. */
+export function formatCommandExample(cmd) {
+    if (cmd.example?.trim())
+        return cmd.example.trim();
+    const parts = [CLI_COMMAND, cmd.site, cmd.name];
+    for (const arg of cmd.args) {
+        if (arg.positional && arg.required) {
+            parts.push(formatValuePlaceholder(arg.name));
+        }
+    }
+    for (const arg of cmd.args) {
+        if (arg.positional || !arg.required)
+            continue;
+        parts.push(`--${arg.name}`);
+        if (arg.type !== 'bool' && arg.type !== 'boolean')
+            parts.push(formatValuePlaceholder(arg.name));
+    }
+    parts.push('-f', 'yaml');
+    return parts.join(' ');
+}
+/** Generate the --help appendix showing registry metadata not exposed by Commander. */
+export function formatRegistryHelpText(cmd) {
+    const lines = [];
+    const choicesArgs = cmd.args.filter(a => a.choices?.length);
+    for (const a of choicesArgs) {
+        const prefix = a.positional ? `<${a.name}>` : `--${a.name}`;
+        const def = a.default != null ? `  (default: ${a.default})` : '';
+        lines.push(`  ${prefix}: ${summarizeChoices(a.choices)}${def}`);
+    }
+    const meta = [];
+    meta.push(`Access: ${cmd.access}`);
+    meta.push(`Browser: ${cmd.browser ? 'yes' : 'no'}`);
+    if (cmd.domain)
+        meta.push(`Domain: ${cmd.domain}`);
+    if (cmd.defaultFormat)
+        meta.push(`Default format: ${cmd.defaultFormat}`);
+    if (cmd.aliases?.length)
+        meta.push(`Aliases: ${cmd.aliases.join(', ')}`);
+    lines.push(meta.join(' | '));
+    lines.push(`Example: ${formatCommandExample(cmd)}`);
+    if (cmd.columns?.length)
+        lines.push(`Output columns: ${cmd.columns.join(', ')}`);
+    return '\n' + lines.join('\n') + '\n';
+}

package/dist/src/serialization.test.d.ts

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

package/dist/src/serialization.test.js

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import { Strategy } from './registry.js';
+import { formatCommandExample, formatRegistryHelpText, serializeCommand } from './serialization.js';
+describe('formatRegistryHelpText', () => {
+    it('summarizes long choices lists so help text stays readable', () => {
+        const cmd = {
+            site: 'demo',
+            name: 'dynamic', access: 'read',
+            description: 'Demo command',
+            strategy: Strategy.PUBLIC,
+            browser: false,
+            args: [
+                {
+                    name: 'field',
+                    help: 'Field to use',
+                    choices: ['all-fields', 'topic', 'title', 'author', 'publication-titles', 'year-published', 'doi'],
+                },
+            ],
+            columns: ['field'],
+        };
+        expect(formatRegistryHelpText(cmd)).toContain('--field: all-fields, topic, title, author, ... (+3 more)');
+    });
+    it('includes aliases in structured serialization and help text', () => {
+        const cmd = {
+            site: 'demo',
+            name: 'get',
+            access: 'read',
+            aliases: ['metadata'],
+            description: 'Demo command',
+            strategy: Strategy.COOKIE,
+            browser: true,
+            args: [],
+        };
+        expect(serializeCommand(cmd)).toMatchObject({
+            command: 'demo/get',
+            access: 'read',
+            aliases: ['metadata'],
+        });
+        expect(formatRegistryHelpText(cmd)).toContain('Aliases: metadata');
+    });
+    it('surfaces access and canonical examples instead of strategy as primary help metadata', () => {
+        const cmd = {
+            site: 'bilibili',
+            name: 'hot',
+            access: 'read',
+            description: 'Bilibili hot videos',
+            strategy: Strategy.COOKIE,
+            browser: true,
+            args: [],
+        };
+        expect(formatCommandExample(cmd)).toBe('webcmd bilibili hot -f yaml');
+        expect(serializeCommand(cmd)).toMatchObject({
+            command: 'bilibili/hot',
+            access: 'read',
+            example: 'webcmd bilibili hot -f yaml',
+        });
+        expect(formatRegistryHelpText(cmd)).toContain('Access: read');
+        expect(formatRegistryHelpText(cmd)).toContain('Example: webcmd bilibili hot -f yaml');
+        expect(formatRegistryHelpText(cmd)).not.toContain('Strategy:');
+    });
+    it('surfaces command default output format in structured serialization and help text', () => {
+        const cmd = {
+            site: 'gemini',
+            name: 'ask',
+            access: 'read',
+            description: 'Ask Gemini',
+            strategy: Strategy.COOKIE,
+            browser: true,
+            args: [],
+            defaultFormat: 'plain',
+        };
+        expect(serializeCommand(cmd)).toMatchObject({
+            command: 'gemini/ask',
+            defaultFormat: 'plain',
+        });
+        expect(formatRegistryHelpText(cmd)).toContain('Default format: plain');
+    });
+});

package/dist/src/skills.d.ts

@@ -0,0 +1,14 @@
+export interface WebcmdSkillInfo {
+    name: string;
+    description: string;
+    version: string;
+    path: string;
+}
+export interface WebcmdSkillReadResult {
+    skill: string;
+    path: string;
+    content: string;
+}
+export declare function getSkillsRoot(packageRoot?: string): string;
+export declare function listWebcmdSkills(packageRoot?: string): WebcmdSkillInfo[];
+export declare function readWebcmdSkill(target: string, relpath?: string, packageRoot?: string): WebcmdSkillReadResult;

package/dist/src/skills.js

@@ -0,0 +1,127 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import yaml from 'js-yaml';
+import { ArgumentError } from './errors.js';
+import { findPackageRoot } from './package-paths.js';
+const MODULE_FILE = fileURLToPath(import.meta.url);
+export function getSkillsRoot(packageRoot = findPackageRoot(MODULE_FILE)) {
+    return path.join(packageRoot, 'skills');
+}
+export function listWebcmdSkills(packageRoot) {
+    const skillsRoot = getSkillsRoot(packageRoot);
+    if (!fs.existsSync(skillsRoot))
+        return [];
+    return fs.readdirSync(skillsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith('webcmd-'))
+        .map((entry) => readSkillInfo(skillsRoot, entry.name))
+        .filter((entry) => entry !== null)
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function readWebcmdSkill(target, relpath = '', packageRoot) {
+    const { name, pathInSkill } = parseSkillTarget(target, relpath);
+    if (!name.startsWith('webcmd-')) {
+        throw new ArgumentError(`Unknown Webcmd skill: ${name}`, 'Run "webcmd skills list" to see available Webcmd skills.');
+    }
+    const skillsRoot = getSkillsRoot(packageRoot);
+    const skillRoot = path.join(skillsRoot, name);
+    if (!isDirectory(skillRoot) || !fs.existsSync(path.join(skillRoot, 'SKILL.md'))) {
+        throw new ArgumentError(`Unknown Webcmd skill: ${name}`, 'Run "webcmd skills list" to see available Webcmd skills.');
+    }
+    const relativePath = normalizeSkillPath(pathInSkill || 'SKILL.md');
+    const absolutePath = path.resolve(skillRoot, relativePath);
+    const relativeToRoot = path.relative(skillRoot, absolutePath);
+    if (relativeToRoot.startsWith('..') || path.isAbsolute(relativeToRoot)) {
+        throw new ArgumentError(`Invalid skill path: ${relativePath}`, 'Skill paths must stay inside the selected Webcmd skill.');
+    }
+    if (!fs.existsSync(absolutePath) || !fs.statSync(absolutePath).isFile()) {
+        throw new ArgumentError(`Skill file not found: ${name}/${relativePath}`, 'Run "webcmd skills list <skill>" is not supported yet; read SKILL.md or a known references/... file.');
+    }
+    return {
+        skill: name,
+        path: relativePath,
+        content: fs.readFileSync(absolutePath, 'utf8'),
+    };
+}
+function readSkillInfo(skillsRoot, name) {
+    const skillMdPath = path.join(skillsRoot, name, 'SKILL.md');
+    if (!fs.existsSync(skillMdPath))
+        return null;
+    const content = fs.readFileSync(skillMdPath, 'utf8');
+    const fm = parseFrontmatter(content);
+    return {
+        name: typeof fm.name === 'string' && fm.name ? fm.name : name,
+        description: typeof fm.description === 'string' ? fm.description : firstBodyParagraph(content),
+        version: typeof fm.version === 'string' || typeof fm.version === 'number' ? String(fm.version) : '',
+        path: `${name}/SKILL.md`,
+    };
+}
+function parseSkillTarget(target, relpath) {
+    const normalizedTarget = normalizeSkillPath(target);
+    if (relpath) {
+        return { name: normalizedTarget, pathInSkill: relpath };
+    }
+    const slash = normalizedTarget.indexOf('/');
+    if (slash === -1) {
+        return { name: normalizedTarget, pathInSkill: '' };
+    }
+    return {
+        name: normalizedTarget.slice(0, slash),
+        pathInSkill: normalizedTarget.slice(slash + 1),
+    };
+}
+function normalizeSkillPath(raw) {
+    const normalized = raw.trim().replace(/\\/g, '/');
+    if (!normalized || normalized.includes('\0')) {
+        throw new ArgumentError('Skill path must be non-empty.');
+    }
+    if (normalized.startsWith('/') || normalized.split('/').some((part) => part === '..')) {
+        throw new ArgumentError(`Invalid skill path: ${raw}`, 'Use a path relative to a Webcmd skill directory.');
+    }
+    return path.posix.normalize(normalized);
+}
+function parseFrontmatter(content) {
+    if (!content.startsWith('---\n'))
+        return {};
+    const end = content.indexOf('\n---', 4);
+    if (end < 0)
+        return {};
+    try {
+        const parsed = yaml.load(content.slice(4, end));
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return parseLooseFrontmatter(content.slice(4, end));
+    }
+}
+function parseLooseFrontmatter(raw) {
+    const out = {};
+    for (const line of raw.split('\n')) {
+        const match = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
+        if (!match)
+            continue;
+        const [, key, value] = match;
+        if (!['name', 'description', 'version'].includes(key))
+            continue;
+        out[key] = value.trim().replace(/^['"]|['"]$/g, '');
+    }
+    return out;
+}
+function firstBodyParagraph(content) {
+    const body = content.startsWith('---\n')
+        ? content.slice(Math.max(content.indexOf('\n---', 4) + 4, 0))
+        : content;
+    const paragraph = body
+        .split(/\n\s*\n/)
+        .map((part) => part.replace(/^#+\s*/gm, '').trim())
+        .find(Boolean);
+    return paragraph ?? '';
+}
+function isDirectory(filePath) {
+    try {
+        return fs.statSync(filePath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/skills.test.d.ts

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

package/dist/src/skills.test.js

@@ -0,0 +1,71 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { ArgumentError } from './errors.js';
+import { listWebcmdSkills, readWebcmdSkill } from './skills.js';
+function makePackageRoot() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'webcmd-skills-'));
+    fs.mkdirSync(path.join(root, 'skills', 'webcmd-browser', 'references'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'skills', 'webcmd-autofix'), { recursive: true });
+    fs.mkdirSync(path.join(root, 'skills', 'smart-search'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'package.json'), '{"name":"@agentrhq/webcmd"}\n');
+    fs.writeFileSync(path.join(root, 'skills', 'webcmd-browser', 'SKILL.md'), [
+        '---',
+        'name: webcmd-browser',
+        'description: Browser control skill',
+        'version: 1.2.3',
+        '---',
+        '',
+        '# Browser',
+        '',
+        'Body.',
+        '',
+    ].join('\n'));
+    fs.writeFileSync(path.join(root, 'skills', 'webcmd-browser', 'references', 'targets.md'), '# Targets\n');
+    fs.writeFileSync(path.join(root, 'skills', 'webcmd-autofix', 'SKILL.md'), [
+        '---',
+        'name: webcmd-autofix',
+        'description: Fix adapters: keep scope narrow',
+        '---',
+        '',
+    ].join('\n'));
+    fs.writeFileSync(path.join(root, 'skills', 'smart-search', 'SKILL.md'), [
+        '---',
+        'name: smart-search',
+        'description: Search skill',
+        '---',
+        '',
+    ].join('\n'));
+    return root;
+}
+describe('webcmd skills content', () => {
+    it('lists only webcmd-prefixed skills', () => {
+        const root = makePackageRoot();
+        expect(listWebcmdSkills(root).map((skill) => skill.name)).toEqual([
+            'webcmd-autofix',
+            'webcmd-browser',
+        ]);
+        expect(listWebcmdSkills(root).find((skill) => skill.name === 'webcmd-autofix')?.description)
+            .toBe('Fix adapters: keep scope narrow');
+    });
+    it('reads a skill SKILL.md and reference file', () => {
+        const root = makePackageRoot();
+        expect(readWebcmdSkill('webcmd-browser', '', root)).toMatchObject({
+            skill: 'webcmd-browser',
+            path: 'SKILL.md',
+        });
+        expect(readWebcmdSkill('webcmd-browser/references/targets.md', '', root)).toMatchObject({
+            skill: 'webcmd-browser',
+            path: 'references/targets.md',
+            content: '# Targets\n',
+        });
+        expect(readWebcmdSkill('webcmd-browser', 'references/targets.md', root).content).toBe('# Targets\n');
+    });
+    it('rejects non-webcmd skills and path traversal', () => {
+        const root = makePackageRoot();
+        expect(() => readWebcmdSkill('smart-search', '', root)).toThrow(ArgumentError);
+        expect(() => readWebcmdSkill('webcmd-browser/../smart-search/SKILL.md', '', root)).toThrow(ArgumentError);
+        expect(() => readWebcmdSkill('webcmd-browser', '../../package.json', root)).toThrow(ArgumentError);
+    });
+});