doubao-cli 0.4.1 → 0.5.0

package/README.md

@@ -11,7 +11,7 @@ npm install --global doubao-cli@latest
 doubao --version
 ```
 
-Upgrade an existing installation with the same command. To run without a global install:
+Upgrade an existing installation with `doubao update`. To run without a global install:
 
 ```bash
 npx --yes doubao-cli@latest status
@@ -37,6 +37,9 @@ 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 update check
+doubao update
+doubao update auto on
 doubao capabilities
 ```
 
@@ -52,6 +55,25 @@ If Doubao is already running without CDP, the command asks for confirmation befo
 
 Set `DOUBAO_CDP_ENDPOINT` if using another port. `sessions send --wait` waits for and returns the completed assistant reply.
 
+### Updates
+
+`doubao update check` compares the running version with npm without changing the installation. `doubao update` installs the latest release globally through npm when an update is available:
+
+```bash
+doubao update check --json
+doubao update
+```
+
+Automatic installation is opt-in and checks at most once every 24 hours:
+
+```bash
+doubao update auto on
+doubao update auto status
+doubao update auto off
+```
+
+An automatic update never blocks the requested Doubao command if npm or the network fails. Set `DOUBAO_CLI_DISABLE_AUTO_UPDATE=1` to skip configured automatic updates in CI or a one-off invocation. Settings are stored under `~/Library/Application Support/doubao-cli/update.json`; override that directory with `DOUBAO_CLI_CONFIG_DIR`.
+
 ### New sessions and attachments
 
 `sessions create` opens a clean composer. A numeric conversation id does not exist until the first message is sent, so `sessions create` without a message returns `conversationId: null`. Create and persist a session in one command by providing its first message:
@@ -97,7 +119,7 @@ No hard-coded UI coordinates, image recognition, Cookie extraction, or private c
 
 ## Limits
 
-Message read/send and attachment upload use stable DOM test ids in the authenticated Doubao renderer over localhost CDP. A Doubao update can change these selectors. The CLI verifies that uploads finish and the exact user message appears in the target conversation before reporting success. The CLI currently accepts up to 50 attachments per command and files up to 100 MiB each; the Doubao service can impose stricter type or size limits.
+Message read/send and attachment upload use stable DOM attributes in the authenticated Doubao renderer over localhost CDP. A Doubao update can change these selectors. The CLI treats image previews and file cards separately, waits for their respective upload completion signals, and verifies both the exact user message and sent attachment count before reporting success. The CLI currently accepts up to 50 attachments per command and files up to 100 MiB each; the Doubao service can impose stricter type or size limits.
 
 ## Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doubao-cli",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "Programmatic control for local Doubao desktop sessions on macOS",
   "author": "Fullstop000 <fullstop1005@gmail.com>",
   "type": "module",

package/src/attachments.mjs

@@ -2,7 +2,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 
 const DROP_AREA = '[data-testid="file_drop_area"]';
+const ATTACHMENT_AREA = '[data-testid="attachment_area"]';
 const ATTACHMENT_ITEM = '[data-testid="attachment_area"] [data-testid="attachment_file_item"]';
+const IMAGE_ITEM = '[data-testid="attachment_area"] [data-testid="mdbox_image"]';
 const MAX_FILE_COUNT = 50;
 const MAX_FILE_BYTES = 100 * 1024 * 1024;
 const CHUNK_BYTES = 384 * 1024;
@@ -98,20 +100,51 @@ async function dispatchDrop(client, stateKey) {
   })()`);
 }
 
-async function waitForUploads(client, expectedCount, timeoutMs) {
+export function attachmentUploadReady(state, expected) {
+  return state.files.length === expected.files
+    && state.files.every((item) => item.available)
+    && state.images.length === expected.images
+    && state.images.every((item) => item.loaded)
+    && !state.progressing;
+}
+
+async function waitForUploads(client, files, timeoutMs) {
+  const expected = {
+    files: files.filter((file) => !file.type.startsWith('image/')).length,
+    images: files.filter((file) => file.type.startsWith('image/')).length,
+  };
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     const state = await client.evaluate(`(() => {
-      const items = [...document.querySelectorAll(${JSON.stringify(ATTACHMENT_ITEM)})].slice(-${expectedCount});
-      return items.map((item) => ({
-        available: item.getAttribute('data-available') === 'true',
-        name: (item.querySelector('[data-testid="message_nested_content_file_name"]')?.innerText || '').trim(),
-        status: (item.querySelector('[data-testid="message_nested_content_file_subtitle"]')?.innerText || '').trim(),
-      }));
+      const area = document.querySelector(${JSON.stringify(ATTACHMENT_AREA)});
+      const fileItems = ${expected.files}
+        ? [...document.querySelectorAll(${JSON.stringify(ATTACHMENT_ITEM)})].slice(-${expected.files})
+        : [];
+      const imageItems = ${expected.images}
+        ? [...document.querySelectorAll(${JSON.stringify(IMAGE_ITEM)})]
+          .filter((item) => !item.closest('[data-testid="attachment_file_item"]'))
+          .slice(-${expected.images})
+        : [];
+      return {
+        files: fileItems.map((item) => ({
+          available: item.getAttribute('data-available') === 'true',
+          name: (item.querySelector('[data-testid="message_nested_content_file_name"]')?.innerText || '').trim(),
+          status: (item.querySelector('[data-testid="message_nested_content_file_subtitle"]')?.innerText || '').trim(),
+        })),
+        images: imageItems.map((item) => {
+          const image = item.querySelector('img[alt="image"]');
+          return { loaded: Boolean(image?.complete && image?.naturalWidth > 0) };
+        }),
+        progressing: /(?:^|\\s)\\d{1,3}%(?:\\s|$)/u.test(area?.innerText || ''),
+        status: (area?.innerText || '').trim(),
+      };
     })()`);
-    if (state.length === expectedCount && state.every((item) => item.available)) return state;
-    const failed = state.find((item) => /(?:失败|不支持|超出|error|failed)/iu.test(item.status));
+    if (attachmentUploadReady(state, expected)) return;
+    const failed = state.files.find((item) => /(?:失败|不支持|超出|error|failed)/iu.test(item.status));
     if (failed) throw new Error(`Doubao failed to upload attachment ${failed.name || ''}: ${failed.status}`.trim());
+    if (/(?:失败|不支持|超出|error|failed)/iu.test(state.status)) {
+      throw new Error(`Doubao failed to upload an attachment: ${state.status}`);
+    }
     await delay(250);
   }
   throw new Error(`Doubao attachments did not finish uploading within ${timeoutMs} ms`);
@@ -123,13 +156,33 @@ async function clearComposerAttachments(client) {
       item.querySelector('[data-testid="message_nested_content_file_delete"]')
         ?.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
     }
+    const area = document.querySelector(${JSON.stringify(ATTACHMENT_AREA)});
+    const imageItems = [...document.querySelectorAll(${JSON.stringify(IMAGE_ITEM)})]
+      .filter((item) => !item.closest('[data-testid="attachment_file_item"]'));
+    for (const image of imageItems) {
+      let container = image.parentElement;
+      while (container && container !== area) {
+        const deleteButton = [...container.children]
+          .find((child) => /(?:^|\\s)delete-btn-[^\\s]+/u.test(child.className || ''));
+        if (deleteButton) {
+          deleteButton.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+          break;
+        }
+        container = container.parentElement;
+      }
+    }
   })()`);
 }
 
 export async function uploadAttachmentsFromClient(client, filePaths, options = {}) {
   const files = await resolveAttachmentFiles(filePaths);
   if (!files.length) return [];
-  const existingAttachmentCount = await client.evaluate(`document.querySelectorAll(${JSON.stringify(ATTACHMENT_ITEM)}).length`);
+  const existingAttachmentCount = await client.evaluate(`(() => {
+    const files = document.querySelectorAll(${JSON.stringify(ATTACHMENT_ITEM)}).length;
+    const images = [...document.querySelectorAll(${JSON.stringify(IMAGE_ITEM)})]
+      .filter((item) => !item.closest('[data-testid="attachment_file_item"]')).length;
+    return files + images;
+  })()`);
   if (existingAttachmentCount) {
     throw new Error('Doubao composer already contains draft attachments; remove them before using --attach');
   }
@@ -139,19 +192,13 @@ export async function uploadAttachmentsFromClient(client, filePaths, options = {
     await stageFiles(client, files, stateKey);
     const dropped = await dispatchDrop(client, stateKey);
     if (dropped.length !== files.length) throw new Error('Doubao did not accept every attachment from the drop event');
-    let uploaded;
     try {
-      uploaded = await waitForUploads(client, files.length, timeoutMs);
+      await waitForUploads(client, files, timeoutMs);
     } catch (error) {
       await clearComposerAttachments(client).catch(() => {});
       throw error;
     }
-    return uploaded.map((item, index) => ({
-      name: item.name || files[index].name,
-      path: files[index].path,
-      size: files[index].size,
-      type: files[index].type,
-    }));
+    return files;
   } finally {
     await client.evaluate(`delete globalThis[${JSON.stringify(stateKey)}]`).catch(() => {});
   }

package/src/automation.mjs

@@ -78,8 +78,14 @@ const READ_MESSAGES_EXPRESSION = `(() => [...document.querySelectorAll('[data-te
     const attachments = [...element.querySelectorAll('[data-testid="message_nested_content_file_name"]')]
       .map((part) => (part.innerText || '').trim())
       .filter(Boolean);
-    return role && (parts.length || attachments.length)
-      ? { role, text: parts.join('\\n'), ...(attachments.length ? { attachments } : {}) }
+    const images = element.querySelectorAll('[data-plugin-identifier="block_type:10052"] img').length;
+    return role && (parts.length || attachments.length || images)
+      ? {
+        role,
+        text: parts.join('\\n'),
+        ...(attachments.length ? { attachments } : {}),
+        ...(images ? { images } : {}),
+      }
       : null;
   })
   .filter(Boolean))()`;
@@ -109,12 +115,16 @@ export function attachmentsConfirmed(before, after, attachments) {
   const beforeCounts = attachmentCounts(before);
   const afterCounts = attachmentCounts(after);
   const expectedCounts = new Map();
-  for (const attachment of attachments) {
+  for (const attachment of attachments.filter((item) => !item.type?.startsWith('image/'))) {
     expectedCounts.set(attachment.name, (expectedCounts.get(attachment.name) || 0) + 1);
   }
-  return [...expectedCounts].every(([name, expected]) => (
+  const filesConfirmed = [...expectedCounts].every(([name, expected]) => (
     (afterCounts.get(name) || 0) - (beforeCounts.get(name) || 0) >= expected
   ));
+  const expectedImages = attachments.filter((item) => item.type?.startsWith('image/')).length;
+  const beforeImages = before.reduce((total, item) => total + (item.role === 'user' ? item.images || 0 : 0), 0);
+  const afterImages = after.reduce((total, item) => total + (item.role === 'user' ? item.images || 0 : 0), 0);
+  return filesConfirmed && afterImages - beforeImages >= expectedImages;
 }
 
 export async function readConversation(id, options = {}) {

package/src/cli.mjs

@@ -6,6 +6,14 @@ import { currentSession, getDataDir, listSessions, resolveProfile } from './stor
 import { cdpStatus } from './cdp.mjs';
 import { createConversation, openConversation, readConversation, sendMessage } from './automation.mjs';
 import { currentModel, listModels, selectModel } from './models.mjs';
+import {
+  checkForUpdate,
+  installUpdate,
+  maybeAutoUpdate,
+  readUpdateState,
+  setAutoUpdate,
+  updateStatePath,
+} from './update.mjs';
 
 const DEFAULT_APP = '/Applications/Doubao.app';
 const CLI_VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
@@ -24,12 +32,17 @@ const HELP = `Usage:
   doubao model select <model> [--json]
   doubao cdp status [--json]
   doubao cdp launch [--yes] [--json]
+  doubao update [--json]
+  doubao update check [--json]
+  doubao update auto <on|off|status> [--json]
   doubao capabilities [--json]
 
 Environment:
   DOUBAO_APP       Override the Doubao.app path
   DOUBAO_DATA_DIR  Override the Doubao user-data directory
   DOUBAO_CDP_ENDPOINT  CDP endpoint (default: http://127.0.0.1:9225)
+  DOUBAO_CLI_CONFIG_DIR  Override the doubao-cli settings directory
+  DOUBAO_CLI_DISABLE_AUTO_UPDATE  Set to 1 to skip configured automatic updates
 `;
 
 export function parseOptions(argv) {
@@ -169,6 +182,16 @@ function sessionWithTitle(profilePath, id) {
   return listSessions(profilePath).find((session) => session.id === id) || { id, title: null };
 }
 
+async function runConfiguredAutoUpdate(command, json) {
+  if (['help', '--help', '-h', 'version', '--version', '-v', 'update'].includes(command)) return;
+  const result = await maybeAutoUpdate(CLI_VERSION);
+  if (result.updated) {
+    if (!json) console.error(`doubao: automatically updated to ${result.latestVersion}; the new version applies next run`);
+  } else if (result.error && !json) {
+    console.error(`doubao: automatic update failed: ${result.error}`);
+  }
+}
+
 export async function main(argv) {
   const { args, profile: requestedProfile, json, yes, wait, timeoutMs, limit, model, attachments } = parseOptions(argv);
   const [command, subcommand, operand] = args;
@@ -183,6 +206,54 @@ export async function main(argv) {
     return;
   }
 
+  if (command === 'update') {
+    if (subcommand === 'auto') {
+      const action = operand || 'status';
+      if (!['on', 'off', 'status'].includes(action)) {
+        throw new Error('update auto requires on, off, or status');
+      }
+      const state = action === 'status'
+        ? await readUpdateState()
+        : await setAutoUpdate(action === 'on');
+      const result = {
+        enabled: state.autoUpdate,
+        lastCheckedAt: state.lastCheckedAt,
+        lastUpdatedVersion: state.lastUpdatedVersion,
+        settingsPath: updateStatePath(),
+      };
+      if (json) output(result, true);
+      else {
+        console.log(`automatic updates\t${result.enabled ? 'on' : 'off'}`);
+        if (result.lastCheckedAt) console.log(`last checked\t${result.lastCheckedAt}`);
+        if (result.lastUpdatedVersion) console.log(`last updated\t${result.lastUpdatedVersion}`);
+      }
+      return;
+    }
+
+    if (subcommand && subcommand !== 'check') {
+      throw new Error(`unknown update command "${subcommand}". Run "doubao help".`);
+    }
+    const check = await checkForUpdate(CLI_VERSION);
+    if (subcommand === 'check') {
+      if (json) output(check, true);
+      else {
+        console.log(`current\t${check.currentVersion}`);
+        console.log(`latest\t${check.latestVersion}`);
+        console.log(`update available\t${check.updateAvailable ? 'yes' : 'no'}`);
+      }
+      return;
+    }
+    const result = check.updateAvailable
+      ? { ...check, ...installUpdate(check.latestVersion, { inherit: !json }) }
+      : { ...check, updated: false };
+    if (json) output(result, true);
+    else if (result.updated) console.log(`updated\t${result.latestVersion}`);
+    else console.log(`up to date\t${result.currentVersion}`);
+    return;
+  }
+
+  await runConfiguredAutoUpdate(command, json);
+
   if (command === 'profiles') {
     const { readProfiles } = await import('./storage.mjs');
     const profiles = readProfiles(dataDir);
@@ -208,6 +279,8 @@ export async function main(argv) {
       sendMessages: cdp.available,
       uploadAttachments: cdp.available,
       selectModels: cdp.available,
+      selfUpdate: true,
+      automaticUpdates: true,
       cdp,
       note: cdp.available
         ? 'Message automation is available through the authenticated Doubao renderer over local CDP.'
@@ -224,6 +297,8 @@ export async function main(argv) {
       console.log(`messages send\t${capabilities.sendMessages ? 'yes' : 'no'}`);
       console.log(`attachments upload\t${capabilities.uploadAttachments ? 'yes' : 'no'}`);
       console.log(`models select\t${capabilities.selectModels ? 'yes' : 'no'}`);
+      console.log('self update\tyes');
+      console.log('automatic updates\tyes');
       console.log(`note\t${capabilities.note}`);
     }
     return;

package/src/update.mjs

@@ -0,0 +1,165 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const PACKAGE_NAME = 'doubao-cli';
+const REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_STATE = Object.freeze({
+  autoUpdate: false,
+  lastCheckedAt: null,
+  lastUpdatedVersion: null,
+});
+
+function parseVersion(version) {
+  const match = /^(?:v)?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u.exec(String(version || '').trim());
+  if (!match) throw new Error(`invalid semantic version "${version}"`);
+  return {
+    numbers: match.slice(1, 4).map(Number),
+    prerelease: match[4]?.split('.') || [],
+  };
+}
+
+function comparePrerelease(left, right) {
+  if (!left.length && !right.length) return 0;
+  if (!left.length) return 1;
+  if (!right.length) return -1;
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    if (left[index] === undefined) return -1;
+    if (right[index] === undefined) return 1;
+    if (left[index] === right[index]) continue;
+    const leftNumber = /^\d+$/u.test(left[index]) ? Number(left[index]) : null;
+    const rightNumber = /^\d+$/u.test(right[index]) ? Number(right[index]) : null;
+    if (leftNumber !== null && rightNumber !== null) return Math.sign(leftNumber - rightNumber);
+    if (leftNumber !== null) return -1;
+    if (rightNumber !== null) return 1;
+    return Math.sign(left[index].localeCompare(right[index], 'en-US'));
+  }
+  return 0;
+}
+
+export function compareVersions(leftVersion, rightVersion) {
+  const left = parseVersion(leftVersion);
+  const right = parseVersion(rightVersion);
+  for (let index = 0; index < left.numbers.length; index += 1) {
+    if (left.numbers[index] !== right.numbers[index]) {
+      return Math.sign(left.numbers[index] - right.numbers[index]);
+    }
+  }
+  return comparePrerelease(left.prerelease, right.prerelease);
+}
+
+export function updateStatePath(env = process.env) {
+  const directory = env.DOUBAO_CLI_CONFIG_DIR
+    || path.join(os.homedir(), 'Library', 'Application Support', PACKAGE_NAME);
+  return path.join(directory, 'update.json');
+}
+
+export async function readUpdateState(env = process.env) {
+  const statePath = updateStatePath(env);
+  try {
+    const parsed = JSON.parse(await fs.readFile(statePath, 'utf8'));
+    return { ...DEFAULT_STATE, ...parsed };
+  } catch (error) {
+    if (error.code === 'ENOENT') return { ...DEFAULT_STATE };
+    throw new Error(`cannot read update settings at ${statePath}: ${error.message}`);
+  }
+}
+
+export async function writeUpdateState(state, env = process.env) {
+  const statePath = updateStatePath(env);
+  await fs.mkdir(path.dirname(statePath), { recursive: true });
+  const temporaryPath = `${statePath}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await fs.writeFile(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    await fs.rename(temporaryPath, statePath);
+  } finally {
+    await fs.rm(temporaryPath, { force: true }).catch(() => {});
+  }
+  return state;
+}
+
+export async function setAutoUpdate(enabled, env = process.env) {
+  const state = await readUpdateState(env);
+  return writeUpdateState({
+    ...state,
+    autoUpdate: Boolean(enabled),
+    ...(enabled ? { lastCheckedAt: null } : {}),
+  }, env);
+}
+
+export async function checkForUpdate(currentVersion, options = {}) {
+  parseVersion(currentVersion);
+  const fetchImpl = options.fetchImpl || fetch;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs || 5000);
+  try {
+    const response = await fetchImpl(REGISTRY_URL, {
+      headers: { accept: 'application/json' },
+      signal: controller.signal,
+    });
+    if (!response.ok) throw new Error(`npm registry returned HTTP ${response.status}`);
+    const payload = await response.json();
+    parseVersion(payload.version);
+    return {
+      currentVersion,
+      latestVersion: payload.version,
+      updateAvailable: compareVersions(currentVersion, payload.version) < 0,
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export function installUpdate(version, options = {}) {
+  parseVersion(version);
+  const spawnImpl = options.spawnImpl || spawnSync;
+  const result = spawnImpl('npm', ['install', '--global', `${PACKAGE_NAME}@${version}`], {
+    encoding: 'utf8',
+    env: options.env || process.env,
+    stdio: options.inherit ? 'inherit' : 'pipe',
+  });
+  if (result.error) throw new Error(`failed to run npm: ${result.error.message}`);
+  if (result.status !== 0) {
+    throw new Error(result.stderr?.trim() || `npm exited with status ${result.status}`);
+  }
+  return { updated: true, version };
+}
+
+function automaticUpdatesDisabled(env) {
+  return /^(?:1|true|yes)$/iu.test(env.DOUBAO_CLI_DISABLE_AUTO_UPDATE || '');
+}
+
+export async function maybeAutoUpdate(currentVersion, options = {}) {
+  const env = options.env || process.env;
+  if (automaticUpdatesDisabled(env)) return { skipped: 'disabled' };
+  try {
+    const state = await readUpdateState(env);
+    if (!state.autoUpdate) return { skipped: 'not-enabled' };
+
+    const now = options.now || Date.now();
+    const lastCheckedAt = state.lastCheckedAt ? Date.parse(state.lastCheckedAt) : 0;
+    if (Number.isFinite(lastCheckedAt) && now - lastCheckedAt < (options.intervalMs || CHECK_INTERVAL_MS)) {
+      return { skipped: 'not-due', state };
+    }
+
+    const check = await checkForUpdate(currentVersion, options);
+    const nextState = {
+      ...state,
+      lastCheckedAt: new Date(now).toISOString(),
+    };
+    await writeUpdateState(nextState, env);
+    if (!check.updateAvailable) {
+      return { ...check, updated: false };
+    }
+    installUpdate(check.latestVersion, options);
+    await writeUpdateState({
+      ...nextState,
+      lastUpdatedVersion: check.latestVersion,
+    }, env);
+    return { ...check, updated: true };
+  } catch (error) {
+    return { error: error.message };
+  }
+}