doubao-cli 0.4.2 → 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:

package/package.json

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

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 };
+  }
+}