doubao-cli 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fullstop000
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+# doubao CLI
+
+Programmatic access to local sessions in the macOS Doubao desktop app.
+
+## Install
+
+```bash
+npm install --global doubao-cli
+```
+
+## Commands
+
+```bash
+doubao status
+doubao profiles
+doubao sessions list
+doubao sessions current
+doubao sessions open 38439138239851266
+doubao sessions read 38439138239851266 --limit 5
+doubao sessions send 38439138239851266 "hello"
+doubao sessions send 38439138239851266 "hello" --wait
+doubao cdp status
+doubao cdp launch
+doubao capabilities
+```
+
+Every data-returning command supports `--json`. Select a non-default local profile with `--profile "Profile 1"` or its display name.
+
+Message automation requires Doubao to be launched with local Chrome DevTools Protocol enabled:
+
+Quit any running Doubao process first, then run `doubao cdp launch`. The equivalent manual command is `open -a /Applications/Doubao.app --args --remote-debugging-port=9225`.
+
+Set `DOUBAO_CDP_ENDPOINT` if using another port. `sessions send --wait` waits for and returns the completed assistant reply.
+
+CDP is unauthenticated but bound to `127.0.0.1`. Quit and relaunch Doubao normally when automation is no longer needed.
+
+## How it works
+
+- 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.
+
+No UI coordinates, image recognition, Cookie extraction, or private credential copying are involved.
+
+## Limits
+
+Message read/send uses stable DOM test ids in the authenticated Doubao renderer over localhost CDP. A Doubao update can change these selectors. The CLI verifies that the exact user message appears in the target conversation before reporting success.
+
+## Development
+
+Requires macOS and Node.js 22 or newer.
+
+```bash
+npm test
+```
+
+Override discovery paths when testing:
+
+```bash
+DOUBAO_APP=/path/to/Doubao.app DOUBAO_DATA_DIR=/path/to/user-data doubao status
+```
+
+## License
+
+MIT © 2026 Fullstop000

package/bin/doubao.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { main } from '../src/cli.mjs';
+
+main(process.argv.slice(2)).catch((error) => {
+  console.error(`doubao: ${error.message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "doubao-cli",
+  "version": "0.2.0",
+  "description": "Programmatic control for local Doubao desktop sessions on macOS",
+  "type": "module",
+  "bin": {
+    "doubao": "bin/doubao.mjs"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Fullstop000/doubao-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Fullstop000/doubao-cli/issues"
+  },
+  "homepage": "https://github.com/Fullstop000/doubao-cli#readme",
+  "keywords": [
+    "doubao",
+    "cli",
+    "macos",
+    "automation",
+    "cdp"
+  ],
+  "license": "MIT"
+}

package/src/automation.mjs

@@ -0,0 +1,117 @@
+import { spawnSync } from 'node:child_process';
+import { withChatClient } from './cdp.mjs';
+
+const CHAT_INPUT = '[data-testid="chat_input_input"] [contenteditable="true"]';
+const SEND_BUTTON = '[data-testid="chat_input_send_button"]';
+
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+export function conversationDeepLink(id) {
+  const webUrl = `https://www.doubao.com/chat/${id}`;
+  return `doubao://doubaoapp/open-url?url=${encodeURIComponent(webUrl)}`;
+}
+
+export function openConversation(id) {
+  const url = conversationDeepLink(id);
+  const result = spawnSync('/usr/bin/open', [url], { encoding: 'utf8' });
+  if (result.status !== 0) throw new Error(result.stderr.trim() || `failed to open ${url}`);
+  return url;
+}
+
+async function waitForConversation(client, id, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const state = await client.evaluate(`({ href: location.href, ready: Boolean(document.querySelector(${JSON.stringify(CHAT_INPUT)})) })`);
+    if (state?.ready && new RegExp(`/chat/${id}(?:[?#]|$)`, 'u').test(state.href)) return state.href;
+    await delay(200);
+  }
+  throw new Error(`Doubao did not open conversation ${id} within ${timeoutMs} ms`);
+}
+
+const READ_MESSAGES_EXPRESSION = `(() => [...document.querySelectorAll('[data-testid="union_message"]')]
+  .map((element) => {
+    const role = element.querySelector('[data-testid="send_message"]')
+      ? 'user'
+      : element.querySelector('[data-testid="receive_message"]') ? 'assistant' : null;
+    const parts = [...element.querySelectorAll('[data-testid="message_text_content"]')]
+      .map((part) => (part.innerText || '').trim())
+      .filter(Boolean);
+    return role && parts.length ? { role, text: parts.join('\\n') } : null;
+  })
+  .filter(Boolean))()`;
+
+async function readFromClient(client) {
+  return await client.evaluate(READ_MESSAGES_EXPRESSION) || [];
+}
+
+export async function readConversation(id, options = {}) {
+  const timeoutMs = options.timeoutMs || 10_000;
+  openConversation(id);
+  return withChatClient(async (client) => {
+    await waitForConversation(client, id, timeoutMs);
+    const messages = await readFromClient(client);
+    return options.limit ? messages.slice(-options.limit) : messages;
+  });
+}
+
+export async function sendMessage(id, message, options = {}) {
+  const timeoutMs = options.timeoutMs || 120_000;
+  const waitForReply = options.waitForReply || false;
+  if (typeof message !== 'string' || !message.trim()) throw new Error('message cannot be empty');
+  if (message.length > 100_000) throw new Error('message exceeds the 100000 character limit');
+
+  openConversation(id);
+  return withChatClient(async (client) => {
+    await waitForConversation(client, id, Math.min(timeoutMs, 15_000));
+    const before = await readFromClient(client);
+    const assistantCountBefore = before.filter((item) => item.role === 'assistant').length;
+    const matchingUserCountBefore = before.filter((item) => item.role === 'user' && item.text === message).length;
+    const encodedMessage = JSON.stringify(message);
+
+    const draft = await client.evaluate(`(async () => {
+      const editor = document.querySelector(${JSON.stringify(CHAT_INPUT)});
+      if (!editor) throw new Error('Doubao message editor was not found');
+      editor.focus();
+      document.execCommand('selectAll', false, null);
+      document.execCommand('insertText', false, ${encodedMessage});
+      await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+      const button = document.querySelector(${JSON.stringify(SEND_BUTTON)});
+      if (!button || button.disabled) throw new Error('Doubao send button is unavailable');
+      const text = (editor.innerText || '').replace(/\\n$/, '');
+      button.click();
+      return text;
+    })()`);
+    if (draft !== message) throw new Error('Doubao editor did not accept the complete message');
+
+    const deadline = Date.now() + timeoutMs;
+    let messages = before;
+    while (Date.now() < deadline) {
+      messages = await readFromClient(client);
+      const matchingUserCount = messages.filter((item) => item.role === 'user' && item.text === message).length;
+      if (matchingUserCount > matchingUserCountBefore) break;
+      await delay(250);
+    }
+    const matchingUserMessages = messages.filter((item) => item.role === 'user' && item.text === message);
+    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 };
+
+    let stableText = '';
+    let stablePolls = 0;
+    while (Date.now() < deadline) {
+      messages = await readFromClient(client);
+      const assistantMessages = messages.filter((item) => item.role === 'assistant');
+      const reply = assistantMessages.length > assistantCountBefore ? assistantMessages.at(-1) : null;
+      const generating = await client.evaluate(`Boolean(document.querySelector('[data-testid="chat_input_local_break_button"], [data-testid="chat_input_end_button"]'))`);
+      if (reply?.text && reply.text === stableText && !generating) stablePolls += 1;
+      else stablePolls = 0;
+      stableText = reply?.text || '';
+      if (reply && stablePolls >= 2) return { conversationId: id, sent, reply };
+      await delay(500);
+    }
+    throw new Error(`Doubao reply did not complete within ${timeoutMs} ms`);
+  });
+}

package/src/cdp.mjs

@@ -0,0 +1,106 @@
+const DEFAULT_ENDPOINT = 'http://127.0.0.1:9225';
+
+export function cdpEndpoint(env = process.env) {
+  return (env.DOUBAO_CDP_ENDPOINT || DEFAULT_ENDPOINT).replace(/\/$/u, '');
+}
+
+async function fetchJson(url, timeoutMs = 3000) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    return await response.json();
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function cdpStatus(endpoint = cdpEndpoint()) {
+  try {
+    const version = await fetchJson(`${endpoint}/json/version`);
+    return { available: true, endpoint, browser: version.Browser, protocolVersion: version['Protocol-Version'] };
+  } catch (error) {
+    return { available: false, endpoint, error: error.message };
+  }
+}
+
+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 class CdpClient {
+  constructor(webSocketUrl) {
+    this.webSocketUrl = webSocketUrl;
+    this.nextId = 1;
+    this.pending = new Map();
+    this.socket = null;
+  }
+
+  async connect() {
+    this.socket = new WebSocket(this.webSocketUrl);
+    await new Promise((resolve, reject) => {
+      this.socket.addEventListener('open', resolve, { once: true });
+      this.socket.addEventListener('error', () => reject(new Error('CDP WebSocket connection failed')), { once: true });
+    });
+    this.socket.addEventListener('message', (event) => {
+      const message = JSON.parse(String(event.data));
+      if (!message.id) return;
+      const pending = this.pending.get(message.id);
+      if (!pending) return;
+      this.pending.delete(message.id);
+      if (message.error) pending.reject(new Error(message.error.message));
+      else pending.resolve(message.result);
+    });
+    this.socket.addEventListener('close', () => {
+      for (const pending of this.pending.values()) pending.reject(new Error('CDP WebSocket closed'));
+      this.pending.clear();
+    });
+    return this;
+  }
+
+  send(method, params = {}) {
+    if (!this.socket || this.socket.readyState !== WebSocket.OPEN) throw new Error('CDP client is not connected');
+    const id = this.nextId;
+    this.nextId += 1;
+    const promise = new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
+    this.socket.send(JSON.stringify({ id, method, params }));
+    return promise;
+  }
+
+  async evaluate(expression) {
+    const result = await this.send('Runtime.evaluate', {
+      expression,
+      awaitPromise: true,
+      returnByValue: true,
+      userGesture: true,
+    });
+    if (result.exceptionDetails) {
+      throw new Error(result.exceptionDetails.exception?.description || result.exceptionDetails.text || 'JavaScript evaluation failed');
+    }
+    return result.result?.value;
+  }
+
+  close() {
+    this.socket?.close();
+  }
+}
+
+export async function withChatClient(callback, endpoint = cdpEndpoint()) {
+  const status = await cdpStatus(endpoint);
+  if (!status.available) {
+    throw new Error(`Doubao CDP is unavailable at ${endpoint}. Restart Doubao with --remote-debugging-port=9225.`);
+  }
+  const target = await findChatTarget(endpoint);
+  const client = await new CdpClient(target.webSocketDebuggerUrl).connect();
+  try {
+    return await callback(client, target);
+  } finally {
+    client.close();
+  }
+}

package/src/cli.mjs

@@ -0,0 +1,256 @@
+import fs from 'node:fs';
+import path from 'node:path';
+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';
+
+const DEFAULT_APP = '/Applications/Doubao.app';
+const CLI_VERSION = '0.2.0';
+
+const HELP = `Usage:
+  doubao status [--profile <name>] [--json]
+  doubao profiles [--json]
+  doubao sessions list [--profile <name>] [--json]
+  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 cdp status [--json]
+  doubao cdp launch [--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)
+`;
+
+function parseOptions(argv) {
+  const args = [];
+  let profile;
+  let json = false;
+  let wait = false;
+  let timeoutSeconds = 120;
+  let limit = 20;
+  for (let index = 0; index < argv.length; index += 1) {
+    if (argv[index] === '--json') {
+      json = true;
+    } else if (argv[index] === '--wait') {
+      wait = true;
+    } else if (argv[index] === '--profile') {
+      profile = argv[index + 1];
+      if (!profile) throw new Error('--profile requires a value');
+      index += 1;
+    } else if (argv[index] === '--timeout') {
+      timeoutSeconds = Number(argv[index + 1]);
+      if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) throw new Error('--timeout requires a positive number of seconds');
+      index += 1;
+    } else if (argv[index] === '--limit') {
+      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 {
+      args.push(argv[index]);
+    }
+  }
+  return { args, profile, json, wait, timeoutMs: timeoutSeconds * 1000, limit };
+}
+
+function output(value, json) {
+  if (json) console.log(JSON.stringify(value, null, 2));
+  else console.log(value);
+}
+
+function appVersion(appPath) {
+  const plist = path.join(appPath, 'Contents', 'Info.plist');
+  const result = spawnSync('/usr/bin/plutil', ['-extract', 'CFBundleShortVersionString', 'raw', plist], {
+    encoding: 'utf8',
+  });
+  return result.status === 0 ? result.stdout.trim() : null;
+}
+
+function appRunning(appPath) {
+  const executable = path.join(appPath, 'Contents', 'MacOS', 'Doubao');
+  return spawnSync('/usr/bin/pgrep', ['-f', executable]).status === 0;
+}
+
+function validateId(value) {
+  if (!/^\d{12,24}$/u.test(value || '')) throw new Error('conversation id must contain 12 to 24 digits');
+  return value;
+}
+
+function sessionWithTitle(profilePath, id) {
+  return listSessions(profilePath).find((session) => session.id === id) || { id, title: null };
+}
+
+export async function main(argv) {
+  const { args, profile: requestedProfile, json, wait, timeoutMs, limit } = parseOptions(argv);
+  const [command, subcommand, operand] = args;
+  const dataDir = getDataDir();
+
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    console.log(HELP);
+    return;
+  }
+  if (command === 'version' || command === '--version' || command === '-v') {
+    console.log(CLI_VERSION);
+    return;
+  }
+
+  if (command === 'profiles') {
+    const { readProfiles } = await import('./storage.mjs');
+    const profiles = readProfiles(dataDir);
+    if (json) output(profiles, true);
+    else {
+      for (const item of profiles.profiles) {
+        const active = item.directory === profiles.lastUsed ? '*' : ' ';
+        console.log(`${active} ${item.directory}\t${item.name}`);
+      }
+    }
+    return;
+  }
+
+  if (command === 'capabilities') {
+    const cdp = await cdpStatus();
+    const capabilities = {
+      status: true,
+      listSessions: true,
+      detectCurrentSession: true,
+      openSession: true,
+      readMessages: cdp.available,
+      sendMessages: cdp.available,
+      cdp,
+      note: cdp.available
+        ? 'Message automation is available through the authenticated Doubao renderer over local CDP.'
+        : 'Restart Doubao with --remote-debugging-port=9225 to enable message automation.',
+    };
+    if (json) output(capabilities, true);
+    else {
+      console.log('status\tyes');
+      console.log('sessions list\tyes');
+      console.log('sessions current\tyes');
+      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(`note\t${capabilities.note}`);
+    }
+    return;
+  }
+
+  if (command === 'cdp' && subcommand === 'status') {
+    const status = await cdpStatus();
+    if (json) output(status, true);
+    else {
+      console.log(`available\t${status.available ? 'yes' : 'no'}`);
+      console.log(`endpoint\t${status.endpoint}`);
+      if (status.browser) console.log(`browser\t${status.browser}`);
+      if (status.error) console.log(`error\t${status.error}`);
+    }
+    if (!status.available) process.exitCode = 1;
+    return;
+  }
+
+  if (command === 'cdp' && subcommand === 'launch') {
+    const existing = await cdpStatus();
+    if (existing.available) {
+      if (json) output(existing, true);
+      else console.log(`available\tyes\nendpoint\t${existing.endpoint}`);
+      return;
+    }
+    const appPath = process.env.DOUBAO_APP || DEFAULT_APP;
+    if (appRunning(appPath)) throw new Error('Doubao is already running without CDP. Quit it completely, then run this command again.');
+    const endpoint = new URL(existing.endpoint);
+    if (endpoint.hostname !== '127.0.0.1' && endpoint.hostname !== 'localhost') {
+      throw new Error('cdp launch only supports a localhost DOUBAO_CDP_ENDPOINT');
+    }
+    const port = endpoint.port || '9225';
+    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) {
+      await new Promise((resolve) => setTimeout(resolve, 250));
+      launched = await cdpStatus();
+    }
+    if (!launched.available) throw new Error(`Doubao launched, but CDP did not become available at ${existing.endpoint}`);
+    if (json) output(launched, true);
+    else console.log(`available\tyes\nendpoint\t${launched.endpoint}`);
+    return;
+  }
+
+  const profile = resolveProfile(dataDir, requestedProfile);
+
+  if (command === 'status') {
+    const appPath = process.env.DOUBAO_APP || DEFAULT_APP;
+    const sessions = listSessions(profile.path);
+    const status = {
+      installed: fs.existsSync(appPath),
+      running: appRunning(appPath),
+      appVersion: appVersion(appPath),
+      appPath,
+      dataDir,
+      profile: { directory: profile.directory, name: profile.name },
+      cachedSessions: sessions.length,
+    };
+    if (json) output(status, true);
+    else {
+      console.log(`installed\t${status.installed ? 'yes' : 'no'}`);
+      console.log(`running\t${status.running ? 'yes' : 'no'}`);
+      console.log(`app version\t${status.appVersion || 'unknown'}`);
+      console.log(`profile\t${profile.directory} (${profile.name})`);
+      console.log(`cached sessions\t${status.cachedSessions}`);
+    }
+    return;
+  }
+
+  if (command !== 'sessions') throw new Error(`unknown command "${command}". Run "doubao help".`);
+
+  if (subcommand === 'list') {
+    const sessions = listSessions(profile.path);
+    if (json) output(sessions, true);
+    else {
+      console.log('CONVERSATION ID\tTITLE');
+      for (const session of sessions) console.log(`${session.id}\t${session.title}`);
+    }
+    return;
+  }
+
+  if (subcommand === 'current') {
+    const id = currentSession(profile.path);
+    if (!id) throw new Error('current Doubao session was not found in the local session store');
+    const session = sessionWithTitle(profile.path, id);
+    if (json) output(session, true);
+    else console.log(`${session.id}\t${session.title || ''}`);
+    return;
+  }
+
+  if (subcommand === 'open') {
+    const id = validateId(operand);
+    const url = openConversation(id);
+    if (json) output({ id, url, opened: true }, true);
+    else console.log(`opened\t${id}`);
+    return;
+  }
+
+  if (subcommand === 'read') {
+    const id = validateId(operand);
+    const messages = await readConversation(id, { limit, timeoutMs });
+    if (json) output({ conversationId: id, messages }, true);
+    else for (const item of messages) console.log(`${item.role}\t${item.text.replaceAll('\n', '\\n')}`);
+    return;
+  }
+
+  if (subcommand === 'send') {
+    const id = validateId(operand);
+    const message = args.slice(3).join(' ');
+    const result = await sendMessage(id, message, { waitForReply: wait, timeoutMs });
+    if (json) output(result, true);
+    else {
+      console.log(`sent\t${result.sent.text}`);
+      if (result.reply) console.log(`reply\t${result.reply.text.replaceAll('\n', '\\n')}`);
+    }
+    return;
+  }
+
+  throw new Error(`unknown sessions command "${subcommand || ''}". Run "doubao help".`);
+}

package/src/storage.mjs

@@ -0,0 +1,193 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const SNAPSHOT_MARKER = Buffer.from('pull_recent_conv_chain_downlink_body');
+const CONVERSATION_ID = Buffer.from('conversation_id');
+const NAME = Buffer.from('name');
+
+export function getDataDir(env = process.env) {
+  return env.DOUBAO_DATA_DIR || path.join(os.homedir(), 'Library', 'Application Support', 'Doubao');
+}
+
+export function readProfiles(dataDir = getDataDir()) {
+  const localStatePath = path.join(dataDir, 'Local State');
+  let state;
+  try {
+    state = JSON.parse(fs.readFileSync(localStatePath, 'utf8'));
+  } catch (error) {
+    throw new Error(`cannot read Doubao profile metadata at ${localStatePath}: ${error.message}`);
+  }
+
+  const infoCache = state.profile?.info_cache || {};
+  return {
+    lastUsed: state.profile?.last_used || null,
+    profiles: Object.entries(infoCache).map(([directory, info]) => ({
+      directory,
+      name: info.name || directory,
+    })),
+  };
+}
+
+export function resolveProfile(dataDir = getDataDir(), requested) {
+  const metadata = readProfiles(dataDir);
+  let selected;
+
+  if (requested) {
+    selected = metadata.profiles.find(
+      (profile) => profile.directory === requested || profile.name === requested,
+    );
+    if (!selected && fs.existsSync(path.join(dataDir, requested))) {
+      selected = { directory: requested, name: requested };
+    }
+    if (!selected) {
+      const available = metadata.profiles.map((profile) => `${profile.directory} (${profile.name})`).join(', ');
+      throw new Error(`unknown profile "${requested}". Available profiles: ${available || 'none'}`);
+    }
+  } else {
+    selected = metadata.profiles.find((profile) => profile.directory === metadata.lastUsed)
+      || metadata.profiles[0];
+  }
+
+  if (!selected) {
+    throw new Error(`no Doubao profiles found under ${dataDir}`);
+  }
+
+  return { ...selected, path: path.join(dataDir, selected.directory) };
+}
+
+function readUnsignedLeb128(buffer, offset) {
+  let value = 0;
+  let shift = 0;
+  for (let cursor = offset; cursor < buffer.length && cursor < offset + 5; cursor += 1) {
+    const byte = buffer[cursor];
+    value |= (byte & 0x7f) << shift;
+    if ((byte & 0x80) === 0) return { value, bytes: cursor - offset + 1 };
+    shift += 7;
+  }
+  return null;
+}
+
+function cleanTitle(value) {
+  const title = value.replaceAll('\u0000', '').trim();
+  if (!title || title.length > 240 || /[\u0001-\u0008\u000b\u000c\u000e-\u001f]/u.test(title)) return null;
+  return title;
+}
+
+function decodeNameValue(buffer, offset, limit) {
+  for (let cursor = offset; cursor < Math.min(limit, offset + 18); cursor += 1) {
+    const marker = buffer[cursor];
+    if (marker !== 0x63 && marker !== 0x22) continue;
+
+    const length = readUnsignedLeb128(buffer, cursor + 1);
+    if (!length || length.value <= 0 || length.value > 1024) continue;
+    const start = cursor + 1 + length.bytes;
+    const end = start + length.value;
+    if (end > limit || end > buffer.length) continue;
+
+    const encoding = marker === 0x63 ? 'utf16le' : 'utf8';
+    const title = cleanTitle(buffer.subarray(start, end).toString(encoding));
+    if (title) return title;
+  }
+  return null;
+}
+
+export function parseSessionSnapshot(buffer, startOffset = 0) {
+  const sessions = [];
+  const seen = new Set();
+  let cursor = startOffset;
+
+  while (cursor < buffer.length) {
+    const keyOffset = buffer.indexOf(CONVERSATION_ID, cursor);
+    if (keyOffset < 0) break;
+
+    const searchStart = keyOffset + CONVERSATION_ID.length;
+    const searchEnd = Math.min(buffer.length, searchStart + 48);
+    const nearby = buffer.subarray(searchStart, searchEnd).toString('latin1');
+    const idMatch = nearby.match(/\d{12,24}/u);
+    if (!idMatch) {
+      cursor = searchStart;
+      continue;
+    }
+
+    const idOffset = searchStart + (idMatch.index || 0);
+    const id = idMatch[0];
+    const nextConversation = buffer.indexOf(CONVERSATION_ID, idOffset + id.length);
+    const recordEnd = nextConversation < 0 ? Math.min(buffer.length, idOffset + 320) : nextConversation;
+    const nameOffset = buffer.indexOf(NAME, idOffset + id.length);
+
+    if (nameOffset >= 0 && nameOffset < recordEnd && !seen.has(id)) {
+      const title = decodeNameValue(buffer, nameOffset + NAME.length, recordEnd);
+      if (title) {
+        sessions.push({ id, title });
+        seen.add(id);
+      }
+    }
+    cursor = idOffset + id.length;
+  }
+
+  return sessions;
+}
+
+function cacheFiles(profilePath) {
+  const directory = path.join(profilePath, 'IndexedDB', 'chrome_doubao-chat_0.indexeddb.leveldb');
+  let entries;
+  try {
+    entries = fs.readdirSync(directory, { withFileTypes: true });
+  } catch (error) {
+    throw new Error(`cannot read Doubao session cache at ${directory}: ${error.message}`);
+  }
+
+  return entries
+    .filter((entry) => entry.isFile() && /\.(?:log|ldb)$/u.test(entry.name))
+    .map((entry) => {
+      const filePath = path.join(directory, entry.name);
+      return { path: filePath, mtimeMs: fs.statSync(filePath).mtimeMs };
+    })
+    .sort((left, right) => right.mtimeMs - left.mtimeMs);
+}
+
+export function listSessions(profilePath) {
+  for (const file of cacheFiles(profilePath)) {
+    const buffer = fs.readFileSync(file.path);
+    let markerOffset = buffer.lastIndexOf(SNAPSHOT_MARKER);
+    while (markerOffset >= 0) {
+      const sessions = parseSessionSnapshot(buffer, markerOffset + SNAPSHOT_MARKER.length);
+      if (sessions.length) return sessions;
+      markerOffset = buffer.lastIndexOf(SNAPSHOT_MARKER, markerOffset - 1);
+    }
+  }
+  return [];
+}
+
+function idsInBuffer(buffer) {
+  const ids = [];
+  for (const encoding of ['utf8', 'utf16le']) {
+    const text = buffer.toString(encoding);
+    const pattern = /(?:doubao|chrome):\/\/doubao-chat\/chat\/(\d{12,24})/gu;
+    for (const match of text.matchAll(pattern)) ids.push({ id: match[1], index: match.index || 0 });
+  }
+  return ids.sort((left, right) => left.index - right.index);
+}
+
+export function currentSession(profilePath) {
+  const directory = path.join(profilePath, 'Sessions');
+  let files;
+  try {
+    files = fs.readdirSync(directory, { withFileTypes: true })
+      .filter((entry) => entry.isFile() && /^(?:Session|Tabs)_/u.test(entry.name))
+      .map((entry) => {
+        const filePath = path.join(directory, entry.name);
+        return { path: filePath, mtimeMs: fs.statSync(filePath).mtimeMs };
+      })
+      .sort((left, right) => right.mtimeMs - left.mtimeMs);
+  } catch {
+    return null;
+  }
+
+  for (const file of files) {
+    const ids = idsInBuffer(fs.readFileSync(file.path));
+    if (ids.length) return ids.at(-1).id;
+  }
+  return null;
+}