@agentrhq/webcmd 0.1.2 → 0.2.1

package/dist/src/execution.js

@@ -18,7 +18,8 @@ import { executePipeline } from './pipeline/index.js';
 import { adapterLoadError, ArgumentError, CommandExecutionError, attachTraceReceipt, getErrorMessage } from './errors.js';
 import { shouldUseBrowserSession } from './capabilityRouting.js';
 import { getBrowserFactory, browserSession, runWithTimeout, DEFAULT_BROWSER_COMMAND_TIMEOUT } from './runtime.js';
-import { resolveProfileContextId } from './browser/profile.js';
+import { profileRouteParams, resolveProfileSelection } from './browser/profile.js';
+import { setDaemonCommandTimeoutSeconds } from './browser/daemon-client.js';
 import { emitHook } from './hooks.js';
 import { log } from './logger.js';
 import { isElectronApp } from './electron-apps.js';
@@ -182,6 +183,7 @@ export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
         throw new ArgumentError(getErrorMessage(err));
     }
     const userTimeoutSec = readUserTimeoutSeconds(cmd, kwargs);
+    setDaemonCommandTimeoutSeconds(userTimeoutSec);
     const traceMode = normalizeTraceMode(opts.trace);
     const hookCtx = {
         command: fullName(cmd),
@@ -209,7 +211,9 @@ export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
                 }
             }
             const BrowserFactory = getBrowserFactory(cmd.site);
-            const contextId = resolveProfileContextId(opts.profile);
+            const profileSelection = resolveProfileSelection(opts.profile);
+            const profileRouting = profileRouteParams(profileSelection);
+            const contextId = profileSelection?.contextId;
             const internal = cmd;
             const siteSession = resolveSiteSession(cmd, opts.siteSession);
             const session = resolveAdapterBrowserSession(cmd, siteSession);
@@ -330,7 +334,7 @@ export async function executeCommand(cmd, rawKwargs, debug = false, opts = {}) {
                         await page.closeWindow?.().catch(() => { });
                     throw err;
                 }
-            }, { session, cdpEndpoint, contextId, windowMode, surface: 'adapter', siteSession });
+            }, { session, cdpEndpoint, ...profileRouting, windowMode, surface: 'adapter', siteSession });
         }
         else {
             // Non-browser commands: enforce a timeout only when the command exposes

package/dist/src/execution.test.js

@@ -2,6 +2,16 @@ import { describe, expect, it, vi } from 'vitest';
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+const { mockSetDaemonCommandTimeoutSeconds } = vi.hoisted(() => ({
+    mockSetDaemonCommandTimeoutSeconds: vi.fn(),
+}));
+vi.mock('./browser/daemon-client.js', async () => {
+    const actual = await vi.importActual('./browser/daemon-client.js');
+    return {
+        ...actual,
+        setDaemonCommandTimeoutSeconds: mockSetDaemonCommandTimeoutSeconds,
+    };
+});
 import { executeCommand, prepareCommandArgs } from './execution.js';
 import { ArgumentError, TimeoutError, toEnvelope } from './errors.js';
 import { cli, Strategy } from './registry.js';
@@ -90,6 +100,7 @@ describe('executeCommand — non-browser timeout', () => {
         vi.restoreAllMocks();
     });
     it('applies the user --timeout arg as the ceiling for browser commands (with +30s padding)', async () => {
+        mockSetDaemonCommandTimeoutSeconds.mockClear();
         const closeWindow = vi.fn().mockResolvedValue(undefined);
         const mockPage = { closeWindow };
         vi.spyOn(capRouting, 'shouldUseBrowserSession').mockReturnValue(true);
@@ -112,6 +123,7 @@ describe('executeCommand — non-browser timeout', () => {
             timeout: 35,
             label: 'test-execution/browser-with-timeout',
         });
+        expect(mockSetDaemonCommandTimeoutSeconds).toHaveBeenCalledWith(5);
         vi.restoreAllMocks();
     });
     it('falls back to DEFAULT_BROWSER_COMMAND_TIMEOUT for browser commands without a --timeout arg', async () => {

package/dist/src/external-clis.yaml

@@ -37,34 +37,6 @@
   install:
     default: "npm install -g @larksuite/cli"
 
-- name: longbridge
-  binary: longbridge
-  description: "Longbridge CLI — AI-native market data, account management and trading commands for Longbridge OpenAPI"
-  homepage: "https://open.longbridge.com/zh-CN/docs/cli/"
-  tags: [longbridge, finance, trading, market-data, openapi, ai-agent]
-  install:
-    mac: "brew install --cask longbridge/tap/longbridge-terminal"
-    windows: "scoop install https://open.longbridge.com/longbridge/longbridge-terminal/longbridge.json"
-
-- name: dws
-  binary: dws
-  package: DingTalk Workspace
-  description: "DingTalk Workspace CLI — messages, docs, calendar, contacts and more for humans and AI agents"
-  homepage: "https://github.com/DingTalk-Real-AI/dingtalk-workspace-cli"
-  tags: [dingtalk, collaboration, productivity, ai-agent]
-  install:
-    mac: "npm install -g dingtalk-workspace-cli"
-    linux: "npm install -g dingtalk-workspace-cli"
-
-- name: wecom-cli
-  binary: wecom-cli
-  package: 企业微信
-  description: "WeCom/企业微信 CLI — contacts, todos, meetings, messages, calendar, docs and smart sheets for AI agents"
-  homepage: "https://github.com/WecomTeam/wecom-cli"
-  tags: [wecom, wechat-work, collaboration, productivity, ai-agent]
-  install:
-    default: "npm install -g @wecom/cli"
-
 - name: vercel
   binary: vercel
   description: "Vercel CLI — deploy projects, manage domains, env vars, logs and serverless functions"
@@ -91,15 +63,6 @@
   install:
     default: "uv tool install kabi-discord-cli"
 
-- name: wx
-  binary: wx
-  package: wx-cli
-  description: "WeChat local data CLI — sessions, messages, search, contacts, export for AI agents"
-  homepage: "https://github.com/jackwener/wx-cli"
-  tags: [wechat, messaging, search, export, ai-agent]
-  install:
-    default: "npm install -g @jackwener/wx-cli"
-
 - name: wrangler
   binary: wrangler
   description: "Cloudflare Wrangler — deploy Workers, manage R2/D1/KV, publish Pages"

package/dist/src/external.d.ts

@@ -11,7 +11,7 @@ export interface ExternalCliConfig {
     /**
      * Display alias rendered alongside `name` in help/listing as `name(package)`.
      * Use either the upstream distribution/project name (e.g. `tg-cli`, `discord-cli`)
-     * or a human-readable brand label (e.g. `notion`, `企业微信`) when the bare
+     * or a human-readable brand label (e.g. `notion`, `linear`) when the bare
      * executable name is ambiguous.
      */
     package?: string;

package/dist/src/external.js

@@ -161,16 +161,34 @@ export function executeExternalCli(name, args, preloaded) {
         }
     }
     // 3. Passthrough execution with stdio inherited
-    const result = spawnSync(cli.binary, args, { stdio: 'inherit' });
+    const result = spawnPassthrough(cli.binary, args);
     if (result.error) {
         log.error(`Failed to execute '${cli.binary}': ${result.error.message}`);
         process.exitCode = EXIT_CODES.GENERIC_ERROR;
         return;
     }
+    if (result.signal) {
+        process.exitCode = EXIT_CODES.GENERIC_ERROR;
+        return;
+    }
     if (result.status !== null) {
         process.exitCode = result.status;
     }
 }
+function quoteForCmdShell(token) {
+    if (token !== '' && !/[\s"^&|<>%()]/.test(token))
+        return token;
+    return `"${token.replace(/"/g, '""')}"`;
+}
+function spawnPassthrough(binary, args) {
+    const direct = spawnSync(binary, args, { stdio: 'inherit' });
+    const errorCode = direct.error?.code;
+    if (os.platform() === 'win32' && (errorCode === 'EINVAL' || errorCode === 'ENOENT')) {
+        const command = [binary, ...args].map(quoteForCmdShell).join(' ');
+        return spawnSync(command, { stdio: 'inherit', shell: true });
+    }
+    return direct;
+}
 export function registerExternalCli(name, opts) {
     const userPath = getUserRegistryPath();
     const configDir = path.dirname(userPath);

package/dist/src/external.test.js

@@ -18,7 +18,8 @@ vi.mock('node:os', async () => {
         platform: mockPlatform,
     };
 });
-import { formatExternalCliLabel, installExternalCli, parseCommand } from './external.js';
+import { spawnSync } from 'node:child_process';
+import { executeExternalCli, formatExternalCliLabel, installExternalCli, parseCommand } from './external.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 describe('parseCommand', () => {
     it('splits binaries and quoted arguments without invoking a shell', () => {
@@ -44,32 +45,17 @@ describe('parseCommand', () => {
             }
         }
     });
-    it('registers Longbridge with safe package-manager installers only', () => {
-        const raw = fs.readFileSync(path.join(__dirname, 'external-clis.yaml'), 'utf8');
-        const entries = (yaml.load(raw) || []);
-        const longbridge = entries.find((entry) => entry.name === 'longbridge');
-        expect(longbridge).toMatchObject({
-            binary: 'longbridge',
-            homepage: 'https://open.longbridge.com/zh-CN/docs/cli/',
-            install: {
-                mac: 'brew install --cask longbridge/tap/longbridge-terminal',
-                windows: 'scoop install https://open.longbridge.com/longbridge/longbridge-terminal/longbridge.json',
-            },
-        });
-        expect(longbridge?.install?.linux).toBeUndefined();
-        expect(longbridge?.install?.default).toBeUndefined();
-    });
 });
 describe('formatExternalCliLabel', () => {
     it('shows the package name when the executable name differs', () => {
-        expect(formatExternalCliLabel({ name: 'wx', binary: 'wx', package: 'wx-cli' })).toBe('wx(wx-cli)');
+        expect(formatExternalCliLabel({ name: 'tg', binary: 'tg', package: 'tg-cli' })).toBe('tg(tg-cli)');
     });
     it('keeps the label compact when package and name match', () => {
         expect(formatExternalCliLabel({ name: 'docker', binary: 'docker', package: 'docker' })).toBe('docker');
     });
     it('renders a human-readable brand alias for ambiguous executable names', () => {
         expect(formatExternalCliLabel({ name: 'ntn', binary: 'ntn', package: 'notion' })).toBe('ntn(notion)');
-        expect(formatExternalCliLabel({ name: 'wecom-cli', binary: 'wecom-cli', package: '企业微信' })).toBe('wecom-cli(企业微信)');
+        expect(formatExternalCliLabel({ name: 'lin', binary: 'lin', package: 'linear' })).toBe('lin(linear)');
     });
 });
 describe('installExternalCli', () => {
@@ -108,3 +94,38 @@ describe('installExternalCli', () => {
         expect(mockExecFileSync).toHaveBeenCalledTimes(1);
     });
 });
+describe('executeExternalCli passthrough', () => {
+    const spawnMock = vi.mocked(spawnSync);
+    const cli = { name: 'tg', binary: 'tg', description: '' };
+    beforeEach(() => {
+        spawnMock.mockReset();
+        mockExecFileSync.mockReset();
+        mockExecFileSync.mockReturnValue(Buffer.from(''));
+        mockPlatform.mockReturnValue('darwin');
+        process.exitCode = undefined;
+    });
+    it('retries through the shell on Windows when the binary is a .cmd shim', () => {
+        mockPlatform.mockReturnValue('win32');
+        const einval = Object.assign(new Error('spawnSync tg EINVAL'), { code: 'EINVAL' });
+        spawnMock
+            .mockReturnValueOnce({ error: einval, status: null, signal: null })
+            .mockReturnValueOnce({ status: 0, signal: null });
+        executeExternalCli('tg', ['send', 'hello world', '--to', 'a"b'], [cli]);
+        expect(spawnMock).toHaveBeenCalledTimes(2);
+        expect(spawnMock).toHaveBeenNthCalledWith(1, 'tg', ['send', 'hello world', '--to', 'a"b'], { stdio: 'inherit' });
+        expect(spawnMock).toHaveBeenNthCalledWith(2, 'tg send "hello world" --to "a""b"', { stdio: 'inherit', shell: true });
+        expect(process.exitCode).toBe(0);
+    });
+    it('does not retry through the shell on non-Windows platforms', () => {
+        const einval = Object.assign(new Error('spawnSync tg EINVAL'), { code: 'EINVAL' });
+        spawnMock.mockReturnValueOnce({ error: einval, status: null, signal: null });
+        executeExternalCli('tg', [], [cli]);
+        expect(spawnMock).toHaveBeenCalledTimes(1);
+        expect(process.exitCode).toBe(1);
+    });
+    it('reports a non-zero exit code when the child dies from a signal', () => {
+        spawnMock.mockReturnValueOnce({ status: null, signal: 'SIGKILL' });
+        executeExternalCli('tg', [], [cli]);
+        expect(process.exitCode).toBe(1);
+    });
+});

package/dist/src/generate-release-notes-cli.test.js

@@ -0,0 +1,140 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it, vi } from 'vitest';
+import { loadReleaseContext, runGenerateReleaseNotes } from '../scripts/generate-release-notes.js';
+function createIo() {
+    let stdout = '';
+    let stderr = '';
+    return {
+        io: {
+            writeStdout(chunk) {
+                stdout += chunk;
+            },
+            writeStderr(chunk) {
+                stderr += chunk;
+            },
+        },
+        read() {
+            return { stdout, stderr };
+        },
+    };
+}
+describe('runGenerateReleaseNotes', () => {
+    it('exits 1 with usage text when the tag argument is missing', async () => {
+        const { io, read } = createIo();
+        const exitCode = await runGenerateReleaseNotes(['node', 'script'], {}, {}, io);
+        expect(exitCode).toBe(1);
+        expect(read()).toEqual({
+            stdout: '',
+            stderr: 'Usage: generate-release-notes <tag>\n',
+        });
+    });
+    it('exits 0 and leaves stdout empty when GEMINI_API_KEY is missing', async () => {
+        const { io, read } = createIo();
+        const exitCode = await runGenerateReleaseNotes(['node', 'script', 'v0.0.0'], {}, {}, io);
+        expect(exitCode).toBe(0);
+        expect(read()).toEqual({
+            stdout: '',
+            stderr: 'GEMINI_API_KEY is not set; leaving release-please notes unchanged.\n',
+        });
+    });
+    it('normalizes generated markdown before printing it to stdout', async () => {
+        const { io, read } = createIo();
+        const context = {
+            tag: 'v1.2.3',
+            previousTag: 'v1.2.2',
+            currentRef: 'abcdef1',
+            pullRequests: [
+                {
+                    number: 42,
+                    title: 'feat: improve release notes',
+                    author: { login: 'alice' },
+                    labels: [],
+                    files: [],
+                    url: 'https://example.com/42',
+                },
+            ],
+        };
+        const loadContext = vi.fn(async () => context);
+        const generateText = vi.fn(async () => '## Highlights\n- Better summaries.');
+        const exitCode = await runGenerateReleaseNotes(['node', 'script', 'v1.2.3'], { GEMINI_API_KEY: 'test-key' }, { loadContext, generateText }, io);
+        expect(exitCode).toBe(0);
+        expect(loadContext).toHaveBeenCalledWith('v1.2.3', { GEMINI_API_KEY: 'test-key' });
+        expect(generateText).toHaveBeenCalledOnce();
+        expect(read()).toEqual({
+            stdout: [
+                '## Highlights',
+                '- Better summaries.',
+                '',
+                '## Improvements',
+                'None.',
+                '',
+                '## Fixes',
+                'None.',
+                '',
+                '## Contributors',
+                '- @alice',
+                '',
+                '## Reverts',
+                'None.',
+                '',
+            ].join('\n'),
+            stderr: '',
+        });
+    });
+    it('swallows generator errors and keeps release-please notes intact', async () => {
+        const { io, read } = createIo();
+        const loadContext = vi.fn(async () => {
+            throw new Error('gh timed out');
+        });
+        const exitCode = await runGenerateReleaseNotes(['node', 'script', 'v1.2.3'], { GEMINI_API_KEY: 'test-key' }, { loadContext }, io);
+        expect(exitCode).toBe(0);
+        expect(read()).toEqual({
+            stdout: '',
+            stderr: 'Gemini release notes failed: gh timed out\n',
+        });
+    });
+    it('loads bounded PR diffs into release context', async () => {
+        const gh = vi.fn((args) => {
+            const key = args.join(' ');
+            if (key === 'api repos/acme/webcmd/releases?per_page=100') {
+                return JSON.stringify([{ tag_name: 'v1.2.3' }, { tag_name: 'v1.2.2' }]);
+            }
+            if (key === 'api repos/acme/webcmd/compare/v1.2.2...v1.2.3') {
+                return JSON.stringify({
+                    commits: [
+                        { sha: 'abc123', commit: { message: 'feat: improve releases (#42)\n\nBody' } },
+                    ],
+                });
+            }
+            if (key === 'api repos/acme/webcmd/pulls/42') {
+                return JSON.stringify({
+                    number: 42,
+                    title: 'feat: improve releases',
+                    body: 'Release polish.',
+                    user: { login: 'alice' },
+                    labels: [{ name: 'feature' }],
+                    html_url: 'https://github.com/acme/webcmd/pull/42',
+                    merged_at: '2026-07-03T00:00:00Z',
+                });
+            }
+            if (key === 'api repos/acme/webcmd/pulls/42/files?per_page=100') {
+                return JSON.stringify([{ filename: 'src/release-notes.ts' }]);
+            }
+            if (key === 'pr diff 42 --repo acme/webcmd') {
+                return `diff --git a/src/release-notes.ts b/src/release-notes.ts\n${'x'.repeat(80)}`;
+            }
+            throw new Error(`unexpected gh call: ${key}`);
+        });
+        const context = await loadReleaseContext('v1.2.3', { GITHUB_REPOSITORY: 'acme/webcmd' }, { gh, maxDiffCharacters: 40 });
+        expect(context.pullRequests).toHaveLength(1);
+        expect(context.pullRequests[0]?.diff).toBe('diff --git a/src/release-notes.ts b/src/\n[diff truncated]');
+        expect(gh).toHaveBeenCalledWith(['pr', 'diff', '42', '--repo', 'acme/webcmd']);
+    });
+    it('keeps npm publish unblocked when enhanced release-note editing fails', () => {
+        const workflowPath = fileURLToPath(new URL('../.github/workflows/release.yml', import.meta.url));
+        const workflow = readFileSync(workflowPath, 'utf8');
+        expect(workflow).toMatch(/if gh release edit "\$\{\{ steps\.release\.outputs\.tag_name \}\}" --notes-file "\$RUNNER_TEMP\/release-notes\.md"; then/);
+        expect(workflow).toMatch(/Enhanced release notes could not be applied; keeping release-please notes\./);
+    });
+});

package/dist/src/help.d.ts

@@ -28,9 +28,9 @@ export declare function wrapCommaList(items: readonly string[], opts?: {
 /**
  * Adapter category for help-text grouping.
  *
- * - `site`: web site adapter (real DNS-style domain, e.g. `www.bilibili.com`)
+ * - `site`: web site adapter (real DNS-style domain, e.g. `www.youtube.com`)
  * - `app`: desktop app adapter (Electron/osascript, signaled by `domain: 'localhost'`
- *   or other non-DNS/local endpoint string like `'127.0.0.1'` / `'doubao-app'`)
+ *   or other non-DNS/local endpoint string like `'127.0.0.1'` / `'custom-app'`)
  *
  * Classification is derived from the adapter's `domain` field — no new schema
  * required. Adapters without a `domain` field default to `site` (most are
@@ -43,7 +43,7 @@ export interface RootAdapterGroups {
     external: readonly RootExternalCli[];
     /** Desktop-app adapters (chatgpt-app, chatwise, codex, ...) */
     apps: readonly string[];
-    /** Web-site adapters (bilibili, dianping, ...) */
+    /** Web-site adapters (youtube, reddit, github, ...) */
     sites: readonly string[];
 }
 export interface RootExternalCli {

package/dist/src/help.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { classifyAdapter, formatRootAdapterHelpText } from './help.js';
 describe('classifyAdapter', () => {
     it('classifies DNS-style domains as site', () => {
-        expect(classifyAdapter('www.bilibili.com')).toBe('site');
+        expect(classifyAdapter('www.youtube.com')).toBe('site');
         expect(classifyAdapter('chatgpt.com')).toBe('site');
         expect(classifyAdapter('claude.ai')).toBe('site');
         expect(classifyAdapter('grok.com')).toBe('site');
@@ -10,8 +10,8 @@ describe('classifyAdapter', () => {
     it('classifies localhost as app (Electron / osascript desktop integrations)', () => {
         expect(classifyAdapter('localhost')).toBe('app');
     });
-    it('classifies non-DNS domain strings as app (e.g. literal "doubao-app")', () => {
-        expect(classifyAdapter('doubao-app')).toBe('app');
+    it('classifies non-DNS domain strings as app (e.g. literal "custom-app")', () => {
+        expect(classifyAdapter('custom-app')).toBe('app');
     });
     it('defaults missing domain to site (most adapters without explicit domain are public web scrapers)', () => {
         expect(classifyAdapter(undefined)).toBe('site');
@@ -22,15 +22,15 @@ describe('formatRootAdapterHelpText', () => {
         const text = formatRootAdapterHelpText({
             external: [
                 { name: 'gh', label: 'gh' },
-                { name: 'wx', label: 'wx(wx-cli)' },
+                { name: 'vercel', label: 'vercel' },
             ],
             apps: ['chatwise', 'codex'],
-            sites: ['bilibili'],
+            sites: ['youtube'],
         });
         expect(text).toContain('External CLIs (2):');
         expect(text).toContain('App adapters (2):');
         expect(text).toContain('Site adapters (1):');
-        expect(text).toContain('wx(wx-cli)');
+        expect(text).toContain('vercel');
         expect(text.indexOf('External CLIs')).toBeLessThan(text.indexOf('App adapters'));
         expect(text.indexOf('App adapters')).toBeLessThan(text.indexOf('Site adapters'));
     });
@@ -38,7 +38,7 @@ describe('formatRootAdapterHelpText', () => {
         const text = formatRootAdapterHelpText({
             external: [],
             apps: [],
-            sites: ['bilibili'],
+            sites: ['youtube'],
         });
         expect(text).not.toContain('External CLIs');
         expect(text).not.toContain('App adapters');
@@ -51,7 +51,7 @@ describe('formatRootAdapterHelpText', () => {
         const text = formatRootAdapterHelpText({
             external: [],
             apps: [],
-            sites: ['bilibili'],
+            sites: ['youtube'],
         });
         expect(text).toContain("'webcmd <site> --help -f yaml'");
     });

package/dist/src/main.js

@@ -21,7 +21,6 @@ import { findPackageRoot, getCliManifestPath } from './package-paths.js';
 import { PKG_VERSION } from './version.js';
 import { EXIT_CODES } from './errors.js';
 import { isSupportedNodeVersion, MIN_SUPPORTED_NODE_MAJOR } from './runtime-detect.js';
-import { unsupportedDaemonPortEnvMessage } from './constants.js';
 import { CONFIG_DIR_NAME } from './brand.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -41,10 +40,6 @@ if (typeof globalThis.Bun === 'undefined' && !isSupportedNodeVersion(process.ver
     ].join('\n'));
     process.exit(EXIT_CODES.CONFIG_ERROR);
 }
-if (process.env.WEBCMD_DAEMON_PORT) {
-    process.stderr.write(`error: ${unsupportedDaemonPortEnvMessage(process.env.WEBCMD_DAEMON_PORT)}\n`);
-    process.exit(EXIT_CODES.CONFIG_ERROR);
-}
 // Fast path: --version (only when it's the top-level intent, not passed to a subcommand)
 // e.g. `webcmd --version` or `webcmd -V`, but NOT `webcmd gh --version`
 if (argv[0] === '--version' || argv[0] === '-V') {
@@ -153,7 +148,7 @@ const { rewriteBrowserArgv, BrowserSessionArgvError, escapeLeadingDashPositional
 try {
     let rewritten = rewriteBrowserArgv(process.argv.slice(2));
     // Insert a `--` separator before a required positional whose value starts
-    // with `-` (e.g. BOSS 直聘 securityId tokens; #1160). Skipped when the
+    // with `-` (e.g. opaque securityId tokens; #1160). Skipped when the
     // manifest is unavailable so the user-cli / dev paths still work.
     try {
         const manifestPath = getCliManifestPath(BUILTIN_CLIS);

package/dist/src/manifest-types.d.ts

@@ -30,7 +30,7 @@ export interface ManifestEntry {
     pipeline?: Record<string, unknown>[];
     defaultFormat?: 'table' | 'plain' | 'json' | 'yaml' | 'yml' | 'md' | 'markdown' | 'csv';
     type: 'js';
-    /** Relative path from clis/ dir, e.g. 'bilibili/search.js' */
+    /** Relative path from clis/ dir, e.g. 'youtube/search.js' */
     modulePath?: string;
     /** Relative path to the source file from clis/ dir (e.g. 'site/cmd.js') */
     sourceFile?: string;

package/dist/src/node-network.test.js

@@ -7,14 +7,14 @@ describe('node network proxy decisions', () => {
         expect(hasProxyEnv({})).toBe(false);
     });
     it('routes external https traffic through https_proxy', () => {
-        const decision = decideProxy(new URL('https://www.v2ex.com/api/topics/latest.json'), { https_proxy: 'http://127.0.0.1:7897' });
+        const decision = decideProxy(new URL('https://api.github.com/repos/agentrhq/webcmd'), { https_proxy: 'http://127.0.0.1:7897' });
         expect(decision).toEqual({
             mode: 'proxy',
             proxyUrl: 'http://127.0.0.1:7897',
         });
     });
     it('falls back to HTTP_PROXY for https traffic when HTTPS_PROXY is absent', () => {
-        const decision = decideProxy(new URL('https://www.v2ex.com/api/topics/latest.json'), { HTTP_PROXY: 'http://127.0.0.1:7897' });
+        const decision = decideProxy(new URL('https://api.github.com/repos/agentrhq/webcmd'), { HTTP_PROXY: 'http://127.0.0.1:7897' });
         expect(decision).toEqual({
             mode: 'proxy',
             proxyUrl: 'http://127.0.0.1:7897',
@@ -22,9 +22,9 @@ describe('node network proxy decisions', () => {
     });
     it('bypasses proxies for loopback addresses', () => {
         const env = { https_proxy: 'http://127.0.0.1:7897', http_proxy: 'http://127.0.0.1:7897' };
-        expect(decideProxy(new URL('http://127.0.0.1:19825/status'), env)).toEqual({ mode: 'direct' });
-        expect(decideProxy(new URL('http://localhost:19825/status'), env)).toEqual({ mode: 'direct' });
-        expect(decideProxy(new URL('http://[::1]:19825/status'), env)).toEqual({ mode: 'direct' });
+        expect(decideProxy(new URL('http://127.0.0.1:9777/status'), env)).toEqual({ mode: 'direct' });
+        expect(decideProxy(new URL('http://localhost:9777/status'), env)).toEqual({ mode: 'direct' });
+        expect(decideProxy(new URL('http://[::1]:9777/status'), env)).toEqual({ mode: 'direct' });
     });
     it('honors NO_PROXY domain matches', () => {
         const decision = decideProxy(new URL('https://api.example.com/v1/items'), {

package/dist/src/output.js

@@ -79,7 +79,7 @@ function renderTable(data, opts) {
         footer.push(opts.source);
     if (opts.footerExtra)
         footer.push(opts.footerExtra);
-    console.log(footer.join(' · '));
+    console.log(footer.join(' | '));
 }
 function renderJson(data) {
     console.log(JSON.stringify(data, null, 2));

package/dist/src/pipeline/steps/download.test.js

@@ -89,13 +89,13 @@ describe('stepDownload', () => {
             concurrency: 1,
         }, [
             { url: 'https://www.youtube.com/watch?v=one' },
-            { url: 'https://www.bilibili.com/video/BV1xx411c7mD' },
+            { url: 'https://vimeo.com/12345' },
         ], {});
         expect(getCookies).toHaveBeenCalledWith({ domain: 'www.youtube.com' });
-        expect(getCookies).toHaveBeenCalledWith({ domain: 'www.bilibili.com' });
+        expect(getCookies).toHaveBeenCalledWith({ domain: 'vimeo.com' });
         expect(mockExportCookiesToNetscape).toHaveBeenCalledWith(expect.arrayContaining([
             expect.objectContaining({ name: 'sid-www.youtube.com', domain: 'www.youtube.com' }),
-            expect.objectContaining({ name: 'sid-www.bilibili.com', domain: 'www.bilibili.com' }),
+            expect.objectContaining({ name: 'sid-vimeo.com', domain: 'vimeo.com' }),
         ]), expect.any(String));
         expect(mockYtdlpDownload).toHaveBeenCalledTimes(2);
     });

package/dist/src/registry.test.js

@@ -105,9 +105,9 @@ describe('cli() registration', () => {
 describe('fullName', () => {
     it('returns site/name', () => {
         const cmd = {
-            site: 'bilibili', name: 'hot', access: 'read', description: '', args: [],
+            site: 'youtube', name: 'search', access: 'read', description: '', args: [],
         };
-        expect(fullName(cmd)).toBe('bilibili/hot');
+        expect(fullName(cmd)).toBe('youtube/search');
     });
 });
 describe('strategyLabel', () => {

package/dist/src/release-notes.d.ts

@@ -0,0 +1,38 @@
+export declare const RELEASE_NOTE_SECTIONS: readonly ["Highlights", "Improvements", "Fixes", "Contributors", "Reverts"];
+export type ReleaseNoteSection = typeof RELEASE_NOTE_SECTIONS[number];
+export interface PullRequestLabel {
+    name: string;
+}
+export interface PullRequestFile {
+    path: string;
+}
+export interface PullRequestAuthor {
+    login: string;
+}
+export interface PullRequestDetails {
+    number: number;
+    title: string;
+    body?: string | null;
+    author?: PullRequestAuthor | null;
+    labels: PullRequestLabel[];
+    files: PullRequestFile[];
+    diff?: string;
+    url: string;
+    mergedAt?: string | null;
+}
+export interface ReleaseContext {
+    tag: string;
+    previousTag: string;
+    currentRef: string;
+    pullRequests: PullRequestDetails[];
+}
+export interface CompareCommit {
+    sha: string;
+    message: string;
+    author?: string | null;
+}
+export type GitRunner = (args: readonly string[]) => Promise<string>;
+export declare function extractPullRequestNumber(message: string): number | null;
+export declare function filterReleasePullRequests(prs: PullRequestDetails[]): PullRequestDetails[];
+export declare function normalizeReleaseNotes(raw: string, contributors: string[]): string;
+export declare function buildReleaseNotesPrompt(context: ReleaseContext): string;