@bsbofmusic/cdper-doubao 1.1.2 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsbofmusic/cdper-doubao",
-  "version": "1.1.2",
+  "version": "1.1.3",
   "description": "Standalone Doubao CLI controlled through a user's real Chrome/Edge via CDP Bridge",
   "type": "commonjs",
   "main": "src/public-api.js",
@@ -49,7 +49,6 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@bsbofmusic/cdper-core": "~1.3.3",
-    "yargs": "^17.7.2"
+    "@bsbofmusic/cdper-core": "~1.3.4"
   }
 }

package/src/cli.js

@@ -1,160 +1,346 @@
 #!/usr/bin/env node
 'use strict';
-
+Object.defineProperty(exports, "__esModule", { value: true });
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const yargs = require('yargs/yargs');
-const { hideBin } = require('yargs/helpers');
 const { fullCheck, formatAgentHints, fullReadiness } = require('@bsbofmusic/cdper-core/check');
 const { getRuntimeStatus } = require('@bsbofmusic/cdper-core/runtime_status');
 const { listSessions, cleanupExpired, closeSession } = require('@bsbofmusic/cdper-core/session');
 const { redactValue } = require('@bsbofmusic/cdper-core/redact');
 const { queryDoubao } = require('./doubao');
 const pkg = require('../package.json');
-
+const QUERY_OPTIONS = {
+    json: { type: 'boolean' },
+    mode: { alias: 'm', type: 'string', default: 'expert', choices: ['expert'] },
+    session: { alias: 's', type: 'string' },
+    'conversation-policy': { type: 'string', default: 'auto', choices: ['auto', 'fresh', 'followup'] },
+    wait: { type: 'string', default: 'normal', choices: ['short', 'normal', 'long', 'very_long'] },
+    'expected-duration': { type: 'string', choices: ['short', 'normal', 'long', 'very_long'] },
+    'max-wait-ms': { type: 'number' },
+    'max-wait': { type: 'number' },
+    'progress-every-ms': { type: 'number' },
+    'max-extends': { type: 'number' },
+    driver: { type: 'string', choices: ['puppeteer', 'playwright'] },
+    check: { type: 'boolean', default: true },
+    quiet: { alias: 'q', type: 'boolean' },
+    debug: { alias: 'd', type: 'boolean' },
+};
+const JSON_ONLY_OPTIONS = { json: { type: 'boolean' } };
+const CONFIG_OPTIONS = { ws: { type: 'string', demandOption: true }, json: { type: 'boolean' } };
+const SESSION_OPTIONS = { json: { type: 'boolean' } };
 function writeJson(value) {
-  process.stdout.write(JSON.stringify(redactValue(value), null, 2) + '\n');
+    process.stdout.write(JSON.stringify(redactValue(value), null, 2) + '\n');
+}
+function camelCase(name) {
+    return name.replace(/-([a-z])/g, (_match, chr) => chr.toUpperCase());
+}
+function buildAliasMap(specs) {
+    const aliases = {};
+    for (const [name, spec] of Object.entries(specs)) {
+        if (spec.alias)
+            aliases[spec.alias] = name;
+    }
+    return aliases;
+}
+function coerceOption(name, value, spec) {
+    if (spec.type === 'boolean') {
+        if (typeof value === 'boolean')
+            return value;
+        if (value === undefined)
+            return true;
+        if (/^(true|1)$/i.test(value))
+            return true;
+        if (/^(false|0)$/i.test(value))
+            return false;
+        throw new Error(`Invalid value for ${name}: expected boolean`);
+    }
+    if (value === undefined || typeof value === 'boolean') {
+        throw new Error(`Missing value for ${name}`);
+    }
+    if (spec.type === 'number') {
+        const numberValue = Number(value);
+        if (!Number.isFinite(numberValue))
+            throw new Error(`Invalid value for ${name}: expected number`);
+        return numberValue;
+    }
+    return value;
 }
+function setOption(argv, name, value, specs) {
+    const spec = specs[name];
+    if (!spec)
+        throw new Error(`Unknown argument: ${name}`);
+    const key = camelCase(name);
+    argv[key] = coerceOption(name, value, spec);
+}
+function validateChoices(argv, specs) {
+    for (const [name, spec] of Object.entries(specs)) {
+        const key = camelCase(name);
+        if (!(key in argv) && spec.default !== undefined)
+            argv[key] = spec.default;
+        if (spec.demandOption && (argv[key] === undefined || argv[key] === '')) {
+            throw new Error(`Missing required argument: ${name}`);
+        }
+        if (argv[key] !== undefined && spec.choices && !spec.choices.includes(String(argv[key]))) {
+            throw new Error(`Invalid values:\n  Argument: ${name}, Given: "${argv[key]}", Choices: ${spec.choices.map((choice) => `"${choice}"`).join(', ')}`);
+        }
+    }
+}
+function parseOptions(tokens, specs, maxPositionals) {
+    const argv = { _: [] };
+    const aliases = buildAliasMap(specs);
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (token === '--') {
+            argv._.push(...tokens.slice(index + 1));
+            break;
+        }
+        if (token.startsWith('--no-')) {
+            const name = token.slice(5);
+            const spec = specs[name];
+            if (!spec || spec.type !== 'boolean')
+                throw new Error(`Unknown argument: ${name}`);
+            setOption(argv, name, false, specs);
+            continue;
+        }
+        if (token.startsWith('--')) {
+            const raw = token.slice(2);
+            const equalsIndex = raw.indexOf('=');
+            const name = equalsIndex >= 0 ? raw.slice(0, equalsIndex) : raw;
+            const spec = specs[name];
+            if (!spec)
+                throw new Error(`Unknown argument: ${name}`);
+            const inlineValue = equalsIndex >= 0 ? raw.slice(equalsIndex + 1) : undefined;
+            if (spec.type === 'boolean') {
+                setOption(argv, name, inlineValue ?? true, specs);
+            }
+            else {
+                const nextValue = inlineValue ?? tokens[++index];
+                setOption(argv, name, nextValue, specs);
+            }
+            continue;
+        }
+        if (/^-[A-Za-z]$/.test(token)) {
+            const alias = token.slice(1);
+            const name = aliases[alias];
+            if (!name)
+                throw new Error(`Unknown argument: ${alias}`);
+            const spec = specs[name];
+            if (spec.type === 'boolean')
+                setOption(argv, name, true, specs);
+            else
+                setOption(argv, name, tokens[++index], specs);
+            continue;
+        }
+        if (token.startsWith('-'))
+            throw new Error(`Unknown argument: ${token.replace(/^-+/, '')}`);
+        argv._.push(token);
+    }
+    if (argv._.length > maxPositionals) {
+        throw new Error(`Unknown argument: ${argv._[maxPositionals]}`);
+    }
+    validateChoices(argv, specs);
+    return argv;
+}
+function printHelp() {
+    console.log(`cdper-doubao <query> [options]
+
+Commands:
+  cdper-doubao <text>                Query Doubao
+  cdper-doubao doctor|check          Check environment readiness
+  cdper-doubao status                Show runtime status
+  cdper-doubao session [action] [id] List or close sessions
+  cdper-doubao config set            Save CDP WS config
+  cdper-doubao version               Show version
 
+Options:
+  --json  --mode/-m  --session/-s  --conversation-policy  --wait
+  --max-wait-ms  --progress-every-ms  --max-extends  --driver
+  --check/--no-check  --quiet/-q  --debug/-d  --help`);
+}
+function failCli(error, rawArgs) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    if (rawArgs.includes('--json'))
+        writeJson({ ok: false, error: err.message });
+    else {
+        console.error(err.message);
+        printHelp();
+    }
+    process.exit(1);
+}
+function parseCli(rawArgs) {
+    if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
+        printHelp();
+        process.exit(0);
+    }
+    const args = rawArgs[0] === 'query' && rawArgs[1] && !String(rawArgs[1]).startsWith('-')
+        ? rawArgs.slice(1)
+        : rawArgs.slice();
+    const command = args[0];
+    if (command === 'doctor' || command === 'check' || command === 'status' || command === 'version') {
+        return { command, argv: parseOptions(args.slice(1), JSON_ONLY_OPTIONS, 0) };
+    }
+    if (command === 'session') {
+        const argv = parseOptions(args.slice(1), SESSION_OPTIONS, 2);
+        argv.action = argv._[0];
+        argv.id = argv._[1];
+        return { command, argv };
+    }
+    if (command === 'config') {
+        if (args[1] !== 'set')
+            throw new Error(`Unknown argument: ${args[1] || 'config'}`);
+        return { command: 'config set', argv: parseOptions(args.slice(2), CONFIG_OPTIONS, 0) };
+    }
+    const argv = parseOptions(args, QUERY_OPTIONS, 1);
+    return { command: 'query', argv, text: argv._[0] };
+}
 function parseQueryOptions(argv) {
-  return {
-    mode: argv.mode || 'expert',
-    sessionId: argv.session,
-    conversationPolicy: argv.conversationPolicy,
-    expectedDuration: argv.wait || argv.expectedDuration,
-    maxWaitMs: argv.maxWaitMs ?? argv.maxWait,
-    progressEveryMs: argv.progressEveryMs,
-    maxExtends: argv.maxExtends,
-    driver: argv.driver,
-  };
+    return {
+        mode: argv.mode || 'expert',
+        sessionId: argv.session,
+        conversationPolicy: argv.conversationPolicy,
+        expectedDuration: argv.wait || argv.expectedDuration,
+        maxWaitMs: argv.maxWaitMs ?? argv.maxWait,
+        progressEveryMs: argv.progressEveryMs,
+        maxExtends: argv.maxExtends,
+        driver: argv.driver,
+    };
 }
-
 async function runQuery(text, argv) {
-  if (!text || !String(text).trim()) throw new Error('Query text is required');
-  if (argv.quiet) process.env.QUIET = '1';
-  if (argv.debug) process.env.DEBUG = '1';
-  if (argv.check !== false) {
-    const check = await fullCheck();
-    if (!check.allPassed) {
-      const failure = { ok: false, error: 'environment_not_ready', check, hints: formatAgentHints(check) };
-      if (argv.json) writeJson(failure); else console.error(failure.hints);
-      process.exit(1);
-    }
-  }
-  const result = await queryDoubao(String(text), parseQueryOptions(argv));
-  if (argv.json) {
-    writeJson(result);
-    return;
-  }
-  if (result.content && String(result.content).trim()) {
-    console.log(result.content);
-    return;
-  }
-  throw new Error('No valid Doubao reply received');
+    if (!text || !String(text).trim())
+        throw new Error('Query text is required');
+    if (argv.quiet)
+        process.env.QUIET = '1';
+    if (argv.debug)
+        process.env.DEBUG = '1';
+    if (argv.check !== false) {
+        const check = await fullCheck();
+        if (!check.allPassed) {
+            const failure = { ok: false, error: 'environment_not_ready', check, hints: formatAgentHints(check) };
+            if (argv.json)
+                writeJson(failure);
+            else
+                console.error(failure.hints);
+            process.exit(1);
+        }
+    }
+    const result = await queryDoubao(String(text), parseQueryOptions(argv));
+    if (argv.json) {
+        writeJson(result);
+        return;
+    }
+    if (result.content && String(result.content).trim()) {
+        console.log(result.content);
+        return;
+    }
+    throw new Error('No valid Doubao reply received');
 }
-
 async function runDoctor(argv) {
-  const check = await fullCheck();
-  const readiness = await fullReadiness('doubao').catch((error) => ({ ok: false, error: error.message }));
-  const result = { ok: check.allPassed && readiness.browser === 'ready', version: pkg.version, check, readiness };
-  if (argv.json) writeJson(result);
-  else {
-    console.log(`cdper-doubao ${pkg.version}`);
-    console.log(check.summary);
-    if (!check.allPassed) console.log(formatAgentHints(check));
-    console.log(`Runtime: bridge=${readiness.bridge || 'unknown'} browser=${readiness.browser || 'unknown'} ws=${readiness.ws || 'unknown'}`);
-  }
-  if (!result.ok) process.exit(1);
+    const check = await fullCheck();
+    const readiness = await fullReadiness('doubao').catch((error) => ({ ok: false, error: error.message }));
+    const result = { ok: check.allPassed && readiness.browser === 'ready', version: pkg.version, check, readiness };
+    if (argv.json)
+        writeJson(result);
+    else {
+        console.log(`cdper-doubao ${pkg.version}`);
+        console.log(check.summary);
+        if (!check.allPassed)
+            console.log(formatAgentHints(check));
+        console.log(`Runtime: bridge=${readiness.bridge || 'unknown'} browser=${readiness.browser || 'unknown'} ws=${readiness.ws || 'unknown'}`);
+    }
+    if (!result.ok)
+        process.exit(1);
 }
-
 async function runStatus(argv) {
-  const result = await getRuntimeStatus('doubao');
-  if (argv.json) writeJson(result); else console.log(JSON.stringify(redactValue(result), null, 2));
-  if (!result.ok) process.exit(1);
+    const result = await getRuntimeStatus('doubao');
+    if (argv.json)
+        writeJson(result);
+    else
+        console.log(JSON.stringify(redactValue(result), null, 2));
+    if (!result.ok)
+        process.exit(1);
 }
-
 function runSessions(argv) {
-  const cleaned = cleanupExpired();
-  const sessions = listSessions().filter((s) => s.platform === 'doubao');
-  const result = { ok: true, cleaned, sessions };
-  if (argv.json) writeJson(result);
-  else {
-    console.log(`Doubao sessions (cleaned ${cleaned})`);
-    for (const s of sessions) console.log(`${s.sessionId} turns=${s.turns} ttlMs=${s.ttl}`);
-  }
+    const cleaned = cleanupExpired();
+    const sessions = listSessions().filter((s) => s.platform === 'doubao');
+    const result = { ok: true, cleaned, sessions };
+    if (argv.json)
+        writeJson(result);
+    else {
+        console.log(`Doubao sessions (cleaned ${cleaned})`);
+        for (const s of sessions)
+            console.log(`${s.sessionId} turns=${s.turns} ttlMs=${s.ttl}`);
+    }
 }
-
 function runConfigSet(argv) {
-  const ws = String(argv.ws || '').trim();
-  if (!/^ws:\/\//i.test(ws) || !/token=/i.test(ws)) throw new Error('Expected --ws "ws://<host>:<port>/devtools/browser?token=<token>"');
-  const authPath = path.join(os.homedir(), '.cdp-auth.json');
-  fs.writeFileSync(authPath, JSON.stringify({ ws_url: ws }, null, 2) + '\n', { mode: 0o600 });
-  const result = { ok: true, path: authPath, message: 'Saved CDP WS config' };
-  if (argv.json) writeJson(result); else console.log(`Saved ${authPath}`);
+    const ws = String(argv.ws || '').trim();
+    if (!/^ws:\/\//i.test(ws) || !/token=/i.test(ws)) {
+        throw new Error('Expected --ws "ws://<host>:<port>/devtools/browser?token=<token>"');
+    }
+    const authPath = path.join(os.homedir(), '.cdp-auth.json');
+    fs.writeFileSync(authPath, JSON.stringify({ ws_url: ws }, null, 2) + '\n', { mode: 0o600 });
+    const result = { ok: true, path: authPath, message: 'Saved CDP WS config' };
+    if (argv.json)
+        writeJson(result);
+    else
+        console.log(`Saved ${authPath}`);
 }
-
-function addQueryOptions(cmd) {
-  return cmd
-    .option('json', { type: 'boolean', describe: 'Output JSON' })
-    .option('mode', { alias: 'm', default: 'expert', choices: ['expert'], describe: 'Doubao mode' })
-    .option('session', { alias: 's', type: 'string', describe: 'Session ID' })
-    .option('conversation-policy', { choices: ['auto', 'fresh', 'followup'], default: 'auto', describe: 'Conversation policy' })
-    .option('wait', { choices: ['short', 'normal', 'long', 'very_long'], default: 'normal', describe: 'Wait profile' })
-    .option('expected-duration', { choices: ['short', 'normal', 'long', 'very_long'], describe: 'Alias for --wait' })
-    .option('max-wait-ms', { type: 'number', describe: 'Override max base wait' })
-    .option('max-wait', { type: 'number', describe: 'Alias for --max-wait-ms' })
-    .option('progress-every-ms', { type: 'number', describe: 'Progress snapshot interval' })
-    .option('max-extends', { type: 'number', describe: 'Max 60s wait extensions' })
-    .option('driver', { choices: ['puppeteer', 'playwright'], describe: 'Browser driver (default: CDPER_DRIVER or playwright)' })
-    .option('check', { type: 'boolean', default: true, describe: 'Run environment pre-check before query' })
-    .option('quiet', { alias: 'q', type: 'boolean', describe: 'Quiet logs' })
-    .option('debug', { alias: 'd', type: 'boolean', describe: 'Debug logs' });
+function handleError(argv) {
+    return (error) => {
+        const result = { ok: false, error: error.message, cdp: error.cdp || null };
+        if (argv?.json)
+            writeJson(result);
+        else
+            console.error(JSON.stringify(redactValue(result), null, 2));
+        process.exit(1);
+    };
 }
-
-const rawArgs = hideBin(process.argv);
-const cliArgs = rawArgs[0] === 'query' && rawArgs[1] && !String(rawArgs[1]).startsWith('-')
-  ? rawArgs.slice(1)
-  : rawArgs;
-
-yargs(cliArgs)
-  .scriptName('cdper-doubao')
-  .usage('$0 <query> [options]')
-  .command('$0 <text>', 'Query Doubao', (cmd) => addQueryOptions(cmd.positional('text', { type: 'string', describe: 'Query text' })), async (argv) => runQuery(argv.text, argv).catch(handleError(argv)))
-  .command('doctor', 'Check environment readiness', (cmd) => cmd.option('json', { type: 'boolean' }), async (argv) => runDoctor(argv).catch(handleError(argv)))
-  .command('check', 'Alias for doctor', (cmd) => cmd.option('json', { type: 'boolean' }), async (argv) => runDoctor(argv).catch(handleError(argv)))
-  .command('status', 'Show runtime status', (cmd) => cmd.option('json', { type: 'boolean' }), async (argv) => runStatus(argv).catch(handleError(argv)))
-  .command('session [action] [id]', 'List or close sessions', (cmd) => cmd.positional('action', { type: 'string' }).positional('id', { type: 'string' }).option('json', { type: 'boolean' }), (argv) => {
-    if (argv.action === 'close') {
-      if (!argv.id) return handleError(argv)(new Error('session id is required'));
-      closeSession(argv.id);
-      const r = { ok: true, sessionId: argv.id };
-      if (argv.json) writeJson(r); else console.log(`Closed ${argv.id}`);
-      return;
-    }
-    runSessions(argv);
-  })
-  .command('config set', 'Save CDP WS config', (cmd) => cmd.option('ws', { type: 'string', demandOption: true }).option('json', { type: 'boolean' }), (argv) => { try { runConfigSet(argv); } catch (error) { handleError(argv)(error); } })
-  .command('version', 'Show version', (cmd) => cmd.option('json', { type: 'boolean' }), (argv) => { const r = { ok: true, name: pkg.name, version: pkg.version }; if (argv.json) writeJson(r); else console.log(`${pkg.name} ${pkg.version}`); })
-  .showHelpOnFail(false)
-  .fail((msg, err, yargsInstance) => {
-    const json = rawArgs.includes('--json');
-    const error = err || new Error(msg || 'invalid arguments');
-    if (json) writeJson({ ok: false, error: error.message });
-    else {
-      console.error(error.message);
-      yargsInstance.showHelp('error');
+async function main() {
+    const rawArgs = process.argv.slice(2);
+    let parsed;
+    try {
+        parsed = parseCli(rawArgs);
+    }
+    catch (error) {
+        failCli(error, rawArgs);
+    }
+    const { command, argv, text } = parsed;
+    if (command === 'query')
+        return runQuery(text, argv).catch(handleError(argv));
+    if (command === 'doctor' || command === 'check')
+        return runDoctor(argv).catch(handleError(argv));
+    if (command === 'status')
+        return runStatus(argv).catch(handleError(argv));
+    if (command === 'session') {
+        if (argv.action === 'close') {
+            if (!argv.id)
+                return handleError(argv)(new Error('session id is required'));
+            closeSession(argv.id);
+            const result = { ok: true, sessionId: argv.id };
+            if (argv.json)
+                writeJson(result);
+            else
+                console.log(`Closed ${argv.id}`);
+            return;
+        }
+        runSessions(argv);
+        return;
+    }
+    if (command === 'config set') {
+        try {
+            runConfigSet(argv);
+        }
+        catch (error) {
+            handleError(argv)(error);
+        }
+        return;
+    }
+    if (command === 'version') {
+        const result = { ok: true, name: pkg.name, version: pkg.version };
+        if (argv.json)
+            writeJson(result);
+        else
+            console.log(`${pkg.name} ${pkg.version}`);
     }
-    process.exit(1);
-  })
-  .strict()
-  .help()
-  .parse();
-
-function handleError(argv) {
-  return (error) => {
-    const result = { ok: false, error: error.message, cdp: error.cdp || null };
-    if (argv?.json) writeJson(result); else console.error(JSON.stringify(redactValue(result), null, 2));
-    process.exit(1);
-  };
 }
+main().catch((error) => handleError({})(error));