doubao-cli 0.2.4 → 0.3.1

package/README.md

@@ -4,8 +4,17 @@ Programmatic access to local sessions in the macOS Doubao desktop app.
 
 ## Install
 
+Requires macOS, Node.js 22 or newer, and the Doubao desktop app.
+
+```bash
+npm install --global doubao-cli@latest
+doubao --version
+```
+
+Upgrade an existing installation with the same command. To run without a global install:
+
 ```bash
-npm install --global doubao-cli
+npx --yes doubao-cli@latest status
 ```
 
 ## Commands
@@ -19,6 +28,10 @@ doubao sessions open 38439138239851266
 doubao sessions read 38439138239851266 --limit 5
 doubao sessions send 38439138239851266 "hello"
 doubao sessions send 38439138239851266 "hello" --wait
+doubao models
+doubao model
+doubao model select doubao-2.1-turbo
+doubao sessions send 38439138239851266 "hello" --model gpt-5.6-sol --wait
 doubao cdp status
 doubao cdp launch
 doubao capabilities
@@ -32,6 +45,19 @@ Quit any running Doubao process first, then run `doubao cdp launch`. The equival
 
 Set `DOUBAO_CDP_ENDPOINT` if using another port. `sessions send --wait` waits for and returns the completed assistant reply.
 
+`models` reads the choices currently exposed by the desktop app. `model select` changes the active model, and `sessions send --model` selects a model before sending.
+
+| Model | Value | Short aliases |
+| --- | --- | --- |
+| 自动 | `auto` | `自动` |
+| 豆包 2.1 Turbo | `doubao-2.1-turbo` | `turbo` |
+| 豆包 2.1 Pro | `doubao-2.1-pro` | `pro` |
+| Orange 5.0 | `orange-5.0` | `orange` |
+| Gemini 3.7 Flash | `gemini-3.7-flash` | `gemini` |
+| GPT-5.6 Sol | `gpt-5.6-sol` | `gpt`, `sol` |
+
+Use the value, exact display name, or a short alias anywhere `<model>` is accepted. Run `doubao models` to verify the choices exposed by the installed Doubao version.
+
 CDP is unauthenticated but bound to `127.0.0.1`. Quit and relaunch Doubao normally when automation is no longer needed.
 
 ## How it works
@@ -39,8 +65,9 @@ CDP is unauthenticated but bound to `127.0.0.1`. Quit and relaunch Doubao normal
 - Session ids and titles are read directly from Doubao's local IndexedDB cache.
 - The current session is recovered from Chromium's local session store.
 - Opening a session uses Doubao's registered `doubao://doubaoapp/open-url` deep-link router.
+- Model discovery and selection use the renderer's semantic menu attributes and native CDP input events.
 
-No UI coordinates, image recognition, Cookie extraction, or private credential copying are involved.
+No hard-coded UI coordinates, image recognition, Cookie extraction, or private credential copying are involved.
 
 ## Limits
 
@@ -48,8 +75,6 @@ Message read/send uses stable DOM test ids in the authenticated Doubao renderer
 
 ## Development
 
-Requires macOS and Node.js 22 or newer.
-
 ```bash
 npm test
 ```

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "doubao-cli",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "Programmatic control for local Doubao desktop sessions on macOS",
+  "author": "Fullstop000 <fullstop1005@gmail.com>",
   "type": "module",
   "bin": {
     "doubao": "bin/doubao.mjs"

package/src/automation.mjs

@@ -1,5 +1,6 @@
 import { spawnSync } from 'node:child_process';
 import { withChatClient } from './cdp.mjs';
+import { selectModelFromClient } from './models.mjs';
 
 const CHAT_INPUT = '[data-testid="chat_input_input"] [contenteditable="true"]';
 const SEND_BUTTON = '[data-testid="chat_input_send_button"]';
@@ -73,6 +74,7 @@ export async function sendMessage(id, message, options = {}) {
   openConversation(id);
   return withChatClient(async (client) => {
     await waitForConversation(client, id, Math.min(timeoutMs, 15_000));
+    const selectedModel = options.model ? await selectModelFromClient(client, options.model) : null;
     const before = await readFromClient(client);
     const matchingUserCountBefore = before.filter((item) => item.role === 'user' && item.text === message).length;
     const encodedMessage = JSON.stringify(message);
@@ -104,7 +106,9 @@ export async function sendMessage(id, message, options = {}) {
     const sent = matchingUserMessages.length > matchingUserCountBefore ? matchingUserMessages.at(-1) : null;
     if (!sent) throw new Error(`Doubao did not confirm a new sent message within ${timeoutMs} ms`);
 
-    if (!waitForReply) return { conversationId: id, sent, reply: null };
+    if (!waitForReply) {
+      return { conversationId: id, ...(selectedModel ? { model: selectedModel.name } : {}), sent, reply: null };
+    }
 
     let stableText = '';
     let stablePolls = 0;
@@ -125,7 +129,9 @@ export async function sendMessage(id, message, options = {}) {
       if (reply?.text && reply.text === stableText && !generating) stablePolls += 1;
       else stablePolls = 0;
       stableText = reply?.text || '';
-      if (reply && stablePolls >= 2) return { conversationId: id, sent, reply };
+      if (reply && stablePolls >= 2) {
+        return { conversationId: id, ...(selectedModel ? { model: selectedModel.name } : {}), sent, reply };
+      }
       await delay(500);
     }
     throw new Error(`Doubao reply did not complete within ${timeoutMs} ms`);

package/src/cdp.mjs

@@ -25,13 +25,17 @@ export async function cdpStatus(endpoint = cdpEndpoint()) {
   }
 }
 
-export async function findChatTarget(endpoint = cdpEndpoint()) {
-  const targets = await fetchJson(`${endpoint}/json/list`);
-  const target = targets.find(
-    (item) => item.type === 'page' && /^(?:doubao|chrome):\/\/doubao-chat\/chat(?:\/|$)/u.test(item.url),
-  );
-  if (!target?.webSocketDebuggerUrl) throw new Error(`no Doubao chat page found at ${endpoint}`);
-  return target;
+export async function findChatTarget(endpoint = cdpEndpoint(), timeoutMs = 5000) {
+  const deadline = Date.now() + timeoutMs;
+  do {
+    const targets = await fetchJson(`${endpoint}/json/list`);
+    const target = targets.find(
+      (item) => item.type === 'page' && /^(?:doubao|chrome):\/\/doubao-chat\/chat(?:\/|$)/u.test(item.url),
+    );
+    if (target?.webSocketDebuggerUrl) return target;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  } while (Date.now() < deadline);
+  throw new Error(`no Doubao chat page found at ${endpoint}`);
 }
 
 export class CdpClient {
@@ -86,6 +90,48 @@ export class CdpClient {
     return result.result?.value;
   }
 
+  async click(selector) {
+    const point = await this.evaluate(`(() => {
+      const element = document.querySelector(${JSON.stringify(selector)});
+      if (!element) throw new Error('click target was not found');
+      element.scrollIntoView({ block: 'center', inline: 'center' });
+      const rect = element.getBoundingClientRect();
+      if (!rect.width || !rect.height) throw new Error('click target is not visible');
+      return { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 };
+    })()`);
+    await this.send('Input.dispatchMouseEvent', {
+      type: 'mousePressed',
+      x: point.x,
+      y: point.y,
+      button: 'left',
+      clickCount: 1,
+    });
+    await this.send('Input.dispatchMouseEvent', {
+      type: 'mouseReleased',
+      x: point.x,
+      y: point.y,
+      button: 'left',
+      clickCount: 1,
+    });
+  }
+
+  async pressEscape() {
+    await this.send('Input.dispatchKeyEvent', {
+      type: 'rawKeyDown',
+      key: 'Escape',
+      code: 'Escape',
+      windowsVirtualKeyCode: 27,
+      nativeVirtualKeyCode: 53,
+    });
+    await this.send('Input.dispatchKeyEvent', {
+      type: 'keyUp',
+      key: 'Escape',
+      code: 'Escape',
+      windowsVirtualKeyCode: 27,
+      nativeVirtualKeyCode: 53,
+    });
+  }
+
   close() {
     this.socket?.close();
   }

package/src/cli.mjs

@@ -4,6 +4,7 @@ import { spawnSync } from 'node:child_process';
 import { currentSession, getDataDir, listSessions, resolveProfile } from './storage.mjs';
 import { cdpStatus } from './cdp.mjs';
 import { openConversation, readConversation, sendMessage } from './automation.mjs';
+import { currentModel, listModels, selectModel } from './models.mjs';
 
 const DEFAULT_APP = '/Applications/Doubao.app';
 const CLI_VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
@@ -15,7 +16,10 @@ const HELP = `Usage:
   doubao sessions current [--profile <name>] [--json]
   doubao sessions open <conversation-id>
   doubao sessions read <conversation-id> [--limit <count>] [--json]
-  doubao sessions send <conversation-id> <message> [--wait] [--timeout <seconds>] [--json]
+  doubao sessions send <conversation-id> <message> [--model <model>] [--wait] [--timeout <seconds>] [--json]
+  doubao models [--json]
+  doubao model [--json]
+  doubao model select <model> [--json]
   doubao cdp status [--json]
   doubao cdp launch [--json]
   doubao capabilities [--json]
@@ -33,6 +37,7 @@ function parseOptions(argv) {
   let wait = false;
   let timeoutSeconds = 120;
   let limit = 20;
+  let model;
   for (let index = 0; index < argv.length; index += 1) {
     if (argv[index] === '--json') {
       json = true;
@@ -50,11 +55,15 @@ function parseOptions(argv) {
       limit = Number(argv[index + 1]);
       if (!Number.isInteger(limit) || limit <= 0 || limit > 1000) throw new Error('--limit requires an integer from 1 to 1000');
       index += 1;
+    } else if (argv[index] === '--model') {
+      model = argv[index + 1];
+      if (!model) throw new Error('--model requires a value');
+      index += 1;
     } else {
       args.push(argv[index]);
     }
   }
-  return { args, profile, json, wait, timeoutMs: timeoutSeconds * 1000, limit };
+  return { args, profile, json, wait, timeoutMs: timeoutSeconds * 1000, limit, model };
 }
 
 function output(value, json) {
@@ -85,7 +94,7 @@ function sessionWithTitle(profilePath, id) {
 }
 
 export async function main(argv) {
-  const { args, profile: requestedProfile, json, wait, timeoutMs, limit } = parseOptions(argv);
+  const { args, profile: requestedProfile, json, wait, timeoutMs, limit, model } = parseOptions(argv);
   const [command, subcommand, operand] = args;
   const dataDir = getDataDir();
 
@@ -120,6 +129,7 @@ export async function main(argv) {
       openSession: true,
       readMessages: cdp.available,
       sendMessages: cdp.available,
+      selectModels: cdp.available,
       cdp,
       note: cdp.available
         ? 'Message automation is available through the authenticated Doubao renderer over local CDP.'
@@ -133,11 +143,46 @@ export async function main(argv) {
       console.log('sessions open\tyes');
       console.log(`messages read\t${capabilities.readMessages ? 'yes' : 'no'}`);
       console.log(`messages send\t${capabilities.sendMessages ? 'yes' : 'no'}`);
+      console.log(`models select\t${capabilities.selectModels ? 'yes' : 'no'}`);
       console.log(`note\t${capabilities.note}`);
     }
     return;
   }
 
+  if (command === 'models') {
+    const result = await listModels();
+    if (json) output(result, true);
+    else {
+      console.log('SELECTED\tID\tMODEL');
+      for (const item of result.models) console.log(`${item.selected ? '*' : ''}\t${item.id}\t${item.name}`);
+      if (result.reasoning) console.log(`reasoning\t${result.reasoning}`);
+    }
+    return;
+  }
+
+  if (command === 'model' && (!subcommand || subcommand === 'current')) {
+    const result = await currentModel();
+    if (json) output(result, true);
+    else {
+      console.log(`model\t${result.name}`);
+      console.log(`id\t${result.id}`);
+      if (result.reasoning) console.log(`reasoning\t${result.reasoning}`);
+    }
+    return;
+  }
+
+  if (command === 'model' && subcommand === 'select') {
+    const requestedModel = args.slice(2).join(' ');
+    const result = await selectModel(requestedModel);
+    if (json) output(result, true);
+    else {
+      console.log(`model\t${result.name}`);
+      console.log(`changed\t${result.changed ? 'yes' : 'no'}`);
+      if (result.reasoning) console.log(`reasoning\t${result.reasoning}`);
+    }
+    return;
+  }
+
   if (command === 'cdp' && subcommand === 'status') {
     const status = await cdpStatus();
     if (json) output(status, true);
@@ -168,7 +213,7 @@ export async function main(argv) {
     const result = spawnSync('/usr/bin/open', ['-a', appPath, '--args', `--remote-debugging-port=${port}`], { encoding: 'utf8' });
     if (result.status !== 0) throw new Error(result.stderr.trim() || 'failed to launch Doubao with CDP');
     let launched = existing;
-    for (let attempt = 0; attempt < 30 && !launched.available; attempt += 1) {
+    for (let attempt = 0; attempt < 120 && !launched.available; attempt += 1) {
       await new Promise((resolve) => setTimeout(resolve, 250));
       launched = await cdpStatus();
     }
@@ -243,10 +288,11 @@ export async function main(argv) {
   if (subcommand === 'send') {
     const id = validateId(operand);
     const message = args.slice(3).join(' ');
-    const result = await sendMessage(id, message, { waitForReply: wait, timeoutMs });
+    const result = await sendMessage(id, message, { waitForReply: wait, timeoutMs, model });
     if (json) output(result, true);
     else {
       console.log(`sent\t${result.sent.text}`);
+      if (result.model) console.log(`model\t${result.model}`);
       if (result.reply) console.log(`reply\t${result.reply.text.replaceAll('\n', '\\n')}`);
     }
     return;

package/src/models.mjs

@@ -0,0 +1,200 @@
+import { withChatClient } from './cdp.mjs';
+
+const MODEL_TRIGGER = '[data-valid-btn="model-select-action-btn"]';
+const MODEL_OPTION = '[role="menuitem"][data-slot="dropdown-menu-item"]';
+
+const MODEL_IDS = new Map([
+  ['自动', 'auto'],
+  ['豆包 2.1 Turbo', 'doubao-2.1-turbo'],
+  ['豆包 2.1 Pro', 'doubao-2.1-pro'],
+  ['Orange 5.0', 'orange-5.0'],
+  ['Gemini 3.7 Flash', 'gemini-3.7-flash'],
+  ['GPT-5.6 Sol', 'gpt-5.6-sol'],
+]);
+
+const ALIASES = new Map([
+  ['auto', '自动'],
+  ['自动', '自动'],
+  ['turbo', '豆包 2.1 Turbo'],
+  ['doubao turbo', '豆包 2.1 Turbo'],
+  ['doubao 2.1 turbo', '豆包 2.1 Turbo'],
+  ['pro', '豆包 2.1 Pro'],
+  ['doubao pro', '豆包 2.1 Pro'],
+  ['doubao 2.1 pro', '豆包 2.1 Pro'],
+  ['orange', 'Orange 5.0'],
+  ['orange 5.0', 'Orange 5.0'],
+  ['gemini', 'Gemini 3.7 Flash'],
+  ['gemini flash', 'Gemini 3.7 Flash'],
+  ['gemini 3.7 flash', 'Gemini 3.7 Flash'],
+  ['gpt', 'GPT-5.6 Sol'],
+  ['sol', 'GPT-5.6 Sol'],
+  ['gpt sol', 'GPT-5.6 Sol'],
+  ['gpt 5.6 sol', 'GPT-5.6 Sol'],
+]);
+
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+export function normalizeModelName(value) {
+  return String(value || '')
+    .trim()
+    .toLocaleLowerCase('en-US')
+    .replace(/[_-]+/gu, ' ')
+    .replace(/\s+/gu, ' ');
+}
+
+export function modelId(name) {
+  return MODEL_IDS.get(name) || normalizeModelName(name).replaceAll(' ', '-');
+}
+
+export function resolveModelName(value, availableNames) {
+  const normalized = normalizeModelName(value);
+  if (!normalized) throw new Error('model cannot be empty');
+  const exact = availableNames.find((name) => normalizeModelName(name) === normalized);
+  const alias = ALIASES.get(normalized);
+  const resolved = exact || (alias && availableNames.includes(alias) ? alias : null);
+  if (resolved) return resolved;
+  throw new Error(`unknown model "${value}". Available models: ${availableNames.join(', ')}`);
+}
+
+async function waitFor(client, expression, timeoutMs = 3000, errorMessage = 'Doubao model menu did not respond') {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const value = await client.evaluate(expression);
+    if (value) return value;
+    await delay(50);
+  }
+  throw new Error(errorMessage);
+}
+
+async function closeModelMenu(client, menuId) {
+  await client.pressEscape();
+  await waitFor(client, `(() => {
+    const trigger = document.querySelector(${JSON.stringify(MODEL_TRIGGER)});
+    const controlledId = ${JSON.stringify(menuId || '')} || trigger?.getAttribute('aria-controls');
+    const menu = controlledId ? document.getElementById(controlledId) : null;
+    return trigger?.getAttribute('data-state') !== 'open'
+      && (!menu || menu.getAttribute('data-state') !== 'open') ? true : null;
+  })()`, 1500).catch(() => {});
+  await delay(50);
+}
+
+export async function currentModelFromClient(client) {
+  const state = await waitFor(client, `(() => {
+    const trigger = document.querySelector(${JSON.stringify(MODEL_TRIGGER)});
+    const button = trigger?.querySelector(':scope > button');
+    if (!button) return null;
+    const lines = (button.innerText || button.textContent || '')
+      .split('\\n')
+      .map((line) => line.trim())
+      .filter(Boolean);
+    return { name: lines[0] || null, reasoning: lines.slice(1).join(' ') || null };
+  })()`, 5000, 'Doubao model selector was not found');
+  if (!state?.name) throw new Error('Doubao current model could not be read');
+  return { id: modelId(state.name), ...state };
+}
+
+async function openModelMenu(client) {
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    await closeModelMenu(client);
+    await client.click(MODEL_TRIGGER);
+    try {
+      return await waitFor(client, `(() => {
+        const trigger = document.querySelector(${JSON.stringify(MODEL_TRIGGER)});
+        const menuId = trigger?.getAttribute('aria-controls');
+        const menu = menuId ? document.getElementById(menuId) : null;
+        return menu?.getAttribute('data-state') === 'open' ? menuId : null;
+      })()`, 1500);
+    } catch (error) {
+      await closeModelMenu(client);
+      if (attempt === 1) throw error;
+    }
+  }
+  throw new Error('Doubao model menu did not respond');
+}
+
+async function readOpenOptions(client, menuId) {
+  const options = await client.evaluate(`(() => {
+    const menu = document.getElementById(${JSON.stringify(menuId)});
+    if (!menu) return [];
+    return [...menu.querySelectorAll(${JSON.stringify(MODEL_OPTION)})]
+      .map((item, index) => {
+        const label = item.querySelector('span.shrink-0') || item.querySelector('span');
+        const name = (label?.innerText || label?.textContent || '').trim();
+        return name ? { index, name, selected: Boolean(item.querySelector(':scope > svg')) } : null;
+      })
+      .filter(Boolean);
+  })()`);
+  if (!options?.length) throw new Error('Doubao model menu contains no model options');
+  return options;
+}
+
+export async function listModelsFromClient(client) {
+  const current = await currentModelFromClient(client);
+  let menuId;
+  try {
+    menuId = await openModelMenu(client);
+    const options = await readOpenOptions(client, menuId);
+    return {
+      current: current.name,
+      reasoning: current.reasoning,
+      models: options.map(({ name, selected }) => ({ id: modelId(name), name, selected: selected || name === current.name })),
+    };
+  } finally {
+    if (menuId) await closeModelMenu(client, menuId);
+  }
+}
+
+export async function selectModelFromClient(client, value) {
+  const before = await currentModelFromClient(client);
+  let menuId;
+  let marker;
+  try {
+    menuId = await openModelMenu(client);
+    const options = await readOpenOptions(client, menuId);
+    const name = resolveModelName(value, options.map((option) => option.name));
+    if (name === before.name) return { ...before, changed: false };
+
+    marker = `doubao-cli-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    const marked = await client.evaluate(`(() => {
+      const menu = document.getElementById(${JSON.stringify(menuId)});
+      const item = [...(menu?.querySelectorAll(${JSON.stringify(MODEL_OPTION)}) || [])]
+        .find((candidate) => {
+          const label = candidate.querySelector('span.shrink-0') || candidate.querySelector('span');
+          return (label?.innerText || label?.textContent || '').trim() === ${JSON.stringify(name)};
+        });
+      if (!item) return false;
+      item.setAttribute('data-doubao-cli-model-option', ${JSON.stringify(marker)});
+      return true;
+    })()`);
+    if (!marked) throw new Error(`Doubao model option "${name}" disappeared`);
+    await client.click(`[data-doubao-cli-model-option="${marker}"]`);
+    const selected = await waitFor(client, `(() => {
+      const trigger = document.querySelector(${JSON.stringify(MODEL_TRIGGER)});
+      const button = trigger?.querySelector(':scope > button');
+      const firstLine = (button?.innerText || button?.textContent || '').split('\\n')[0].trim();
+      return firstLine === ${JSON.stringify(name)} ? true : null;
+    })()`);
+    if (!selected) throw new Error(`Doubao did not select model "${name}"`);
+    return { ...(await currentModelFromClient(client)), changed: true };
+  } finally {
+    if (marker) {
+      await client.evaluate(`document.querySelector('[data-doubao-cli-model-option=${JSON.stringify(marker)}]')
+        ?.removeAttribute('data-doubao-cli-model-option')`).catch(() => {});
+    }
+    if (menuId) await closeModelMenu(client, menuId);
+  }
+}
+
+export async function currentModel() {
+  return withChatClient((client) => currentModelFromClient(client));
+}
+
+export async function listModels() {
+  return withChatClient((client) => listModelsFromClient(client));
+}
+
+export async function selectModel(value) {
+  return withChatClient((client) => selectModelFromClient(client, value));
+}