doubao-cli 0.3.1 → 0.4.1

package/README.md

@@ -24,10 +24,13 @@ doubao status
 doubao profiles
 doubao sessions list
 doubao sessions current
+doubao sessions create
+doubao sessions create "summarize the attachment" --attach ./report.pdf --model pro --wait
 doubao sessions open 38439138239851266
 doubao sessions read 38439138239851266 --limit 5
 doubao sessions send 38439138239851266 "hello"
 doubao sessions send 38439138239851266 "hello" --wait
+doubao sessions send 38439138239851266 "compare these files" --attach ./one.pdf --attach ./two.pdf --wait
 doubao models
 doubao model
 doubao model select doubao-2.1-turbo
@@ -41,10 +44,31 @@ Every data-returning command supports `--json`. Select a non-default local profi
 
 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`.
+```bash
+doubao cdp launch
+```
+
+If Doubao is already running without CDP, the command asks for confirmation before quitting it and relaunching with the debugging port enabled. Scripts and `--json` mode never prompt; pass `doubao cdp launch --yes` to confirm the restart explicitly. The command returns only after both the CDP endpoint and authenticated chat renderer are ready. The equivalent manual sequence is to quit Doubao completely and run `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.
 
+### 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:
+
+```bash
+doubao sessions create "Start a new task" --model gpt-5.6-sol --wait --json
+```
+
+Attach one or more local files by repeating `--attach`. The CLI validates each path, transfers the file through the authenticated renderer, waits for Doubao to finish uploading it, and only then sends the message:
+
+```bash
+doubao sessions create "Summarize these" --attach ./brief.pdf --attach ./notes.md --wait
+doubao sessions send 38439138239851266 "Review this spreadsheet" --attach ./data.xlsx --wait
+```
+
+Use `--` before message text that contains CLI option names, for example `doubao sessions create -- "Explain --model literally"`.
+
 `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 |
@@ -66,12 +90,14 @@ CDP is unauthenticated but bound to `127.0.0.1`. Quit and relaunch Doubao normal
 - 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.
+- New sessions use Doubao's blank `/chat` route and return the id assigned after the first confirmed send.
+- Attachments are transferred into the renderer through its drop-upload path; file contents and credentials are never printed.
 
 No hard-coded 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.
+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.
 
 ## Development
 

package/package.json

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

package/src/attachments.mjs

@@ -0,0 +1,158 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const DROP_AREA = '[data-testid="file_drop_area"]';
+const ATTACHMENT_ITEM = '[data-testid="attachment_area"] [data-testid="attachment_file_item"]';
+const MAX_FILE_COUNT = 50;
+const MAX_FILE_BYTES = 100 * 1024 * 1024;
+const CHUNK_BYTES = 384 * 1024;
+
+const MIME_TYPES = new Map([
+  ['.csv', 'text/csv'],
+  ['.doc', 'application/msword'],
+  ['.docx', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'],
+  ['.epub', 'application/epub+zip'],
+  ['.gif', 'image/gif'],
+  ['.jpeg', 'image/jpeg'],
+  ['.jpg', 'image/jpeg'],
+  ['.json', 'application/json'],
+  ['.md', 'text/markdown'],
+  ['.mobi', 'application/x-mobipocket-ebook'],
+  ['.pdf', 'application/pdf'],
+  ['.png', 'image/png'],
+  ['.ppt', 'application/vnd.ms-powerpoint'],
+  ['.pptx', 'application/vnd.openxmlformats-officedocument.presentationml.presentation'],
+  ['.txt', 'text/plain'],
+  ['.webp', 'image/webp'],
+  ['.xls', 'application/vnd.ms-excel'],
+  ['.xlsx', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
+]);
+
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+export function attachmentMimeType(filePath) {
+  return MIME_TYPES.get(path.extname(filePath).toLocaleLowerCase('en-US')) || 'application/octet-stream';
+}
+
+export async function resolveAttachmentFiles(filePaths) {
+  if (!Array.isArray(filePaths) || !filePaths.length) return [];
+  if (filePaths.length > MAX_FILE_COUNT) throw new Error(`at most ${MAX_FILE_COUNT} attachments can be uploaded at once`);
+
+  const files = [];
+  for (const input of filePaths) {
+    const resolvedPath = path.resolve(input);
+    let stat;
+    try {
+      stat = await fs.stat(resolvedPath);
+    } catch {
+      throw new Error(`attachment does not exist: ${resolvedPath}`);
+    }
+    if (!stat.isFile()) throw new Error(`attachment is not a regular file: ${resolvedPath}`);
+    if (stat.size > MAX_FILE_BYTES) throw new Error(`attachment exceeds the 100 MiB CLI limit: ${resolvedPath}`);
+    files.push({
+      path: resolvedPath,
+      name: path.basename(resolvedPath),
+      size: stat.size,
+      type: attachmentMimeType(resolvedPath),
+      lastModified: Math.trunc(stat.mtimeMs),
+    });
+  }
+  return files;
+}
+
+async function stageFiles(client, files, stateKey) {
+  await client.evaluate(`globalThis[${JSON.stringify(stateKey)}] = []`);
+  for (const [index, file] of files.entries()) {
+    await client.evaluate(`globalThis[${JSON.stringify(stateKey)}].push({
+      name: ${JSON.stringify(file.name)},
+      type: ${JSON.stringify(file.type)},
+      lastModified: ${file.lastModified},
+      chunks: [],
+    })`);
+    const bytes = await fs.readFile(file.path);
+    for (let offset = 0; offset < bytes.length; offset += CHUNK_BYTES) {
+      const base64 = bytes.subarray(offset, offset + CHUNK_BYTES).toString('base64');
+      await client.evaluate(`globalThis[${JSON.stringify(stateKey)}][${index}].chunks.push(
+        Uint8Array.from(atob(${JSON.stringify(base64)}), (character) => character.charCodeAt(0)),
+      )`);
+    }
+  }
+}
+
+async function dispatchDrop(client, stateKey) {
+  return client.evaluate(`(() => {
+    const records = globalThis[${JSON.stringify(stateKey)}];
+    const target = document.querySelector(${JSON.stringify(DROP_AREA)})?.parentElement;
+    if (!target) throw new Error('Doubao attachment drop target was not found');
+    const transfer = new DataTransfer();
+    for (const record of records) {
+      transfer.items.add(new File(record.chunks, record.name, {
+        type: record.type,
+        lastModified: record.lastModified,
+      }));
+    }
+    target.dispatchEvent(new DragEvent('drop', { bubbles: true, cancelable: true, dataTransfer: transfer }));
+    return [...transfer.files].map((file) => ({ name: file.name, size: file.size, type: file.type }));
+  })()`);
+}
+
+async function waitForUploads(client, expectedCount, timeoutMs) {
+  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(),
+      }));
+    })()`);
+    if (state.length === expectedCount && state.every((item) => item.available)) return state;
+    const failed = state.find((item) => /(?:失败|不支持|超出|error|failed)/iu.test(item.status));
+    if (failed) throw new Error(`Doubao failed to upload attachment ${failed.name || ''}: ${failed.status}`.trim());
+    await delay(250);
+  }
+  throw new Error(`Doubao attachments did not finish uploading within ${timeoutMs} ms`);
+}
+
+async function clearComposerAttachments(client) {
+  await client.evaluate(`(() => {
+    for (const item of document.querySelectorAll(${JSON.stringify(ATTACHMENT_ITEM)})) {
+      item.querySelector('[data-testid="message_nested_content_file_delete"]')
+        ?.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+    }
+  })()`);
+}
+
+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`);
+  if (existingAttachmentCount) {
+    throw new Error('Doubao composer already contains draft attachments; remove them before using --attach');
+  }
+  const timeoutMs = options.timeoutMs || 60_000;
+  const stateKey = `__doubaoCliUpload_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  try {
+    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);
+    } 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,
+    }));
+  } finally {
+    await client.evaluate(`delete globalThis[${JSON.stringify(stateKey)}]`).catch(() => {});
+  }
+}

package/src/automation.mjs

@@ -1,14 +1,23 @@
 import { spawnSync } from 'node:child_process';
+import { uploadAttachmentsFromClient } from './attachments.mjs';
 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"]';
+const CREATE_BUTTON = '[data-testid="create_conversation_button"]';
+const CREATE_OFFICE_TASK = '[data-testid="create_office_task_button"]';
 
 function delay(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
+function remainingMilliseconds(deadline, timeoutMs) {
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) throw new Error(`Doubao operation did not complete within ${timeoutMs} ms`);
+  return remaining;
+}
+
 export function conversationDeepLink(id) {
   const webUrl = `https://www.doubao.com/chat/${id}`;
   return `doubao://doubaoapp/open-url?url=${encodeURIComponent(webUrl)}`;
@@ -21,6 +30,10 @@ export function openConversation(id) {
   return url;
 }
 
+export function conversationIdFromUrl(url) {
+  return /\/chat\/(\d{12,24})(?:[?#]|$)/u.exec(url || '')?.[1] || null;
+}
+
 async function waitForConversation(client, id, timeoutMs) {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
@@ -31,6 +44,29 @@ async function waitForConversation(client, id, timeoutMs) {
   throw new Error(`Doubao did not open conversation ${id} within ${timeoutMs} ms`);
 }
 
+async function waitForBlankConversation(client, 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 && /\/chat(?:[?#]|$)/u.test(state.href)) return state.href;
+    await delay(100);
+  }
+  throw new Error(`Doubao did not open a blank conversation within ${timeoutMs} ms`);
+}
+
+async function waitForConversationId(client, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const id = conversationIdFromUrl(await client.evaluate('location.href'));
+    if (id) return id;
+    await delay(100);
+  }
+  throw new Error(`Doubao did not assign a 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"]')
@@ -39,7 +75,12 @@ const READ_MESSAGES_EXPRESSION = `(() => [...document.querySelectorAll('[data-te
     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;
+    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 } : {}) }
+      : null;
   })
   .filter(Boolean))()`;
 
@@ -55,6 +96,27 @@ export function replyAfterLastUserMessage(messages, message) {
   return null;
 }
 
+function attachmentCounts(messages) {
+  const counts = new Map();
+  for (const item of messages) {
+    if (item.role !== 'user') continue;
+    for (const name of item.attachments || []) counts.set(name, (counts.get(name) || 0) + 1);
+  }
+  return counts;
+}
+
+export function attachmentsConfirmed(before, after, attachments) {
+  const beforeCounts = attachmentCounts(before);
+  const afterCounts = attachmentCounts(after);
+  const expectedCounts = new Map();
+  for (const attachment of attachments) {
+    expectedCounts.set(attachment.name, (expectedCounts.get(attachment.name) || 0) + 1);
+  }
+  return [...expectedCounts].every(([name, expected]) => (
+    (afterCounts.get(name) || 0) - (beforeCounts.get(name) || 0) >= expected
+  ));
+}
+
 export async function readConversation(id, options = {}) {
   const timeoutMs = options.timeoutMs || 10_000;
   openConversation(id);
@@ -65,75 +127,146 @@ export async function readConversation(id, options = {}) {
   });
 }
 
-export async function sendMessage(id, message, options = {}) {
-  const timeoutMs = options.timeoutMs || 120_000;
-  const waitForReply = options.waitForReply || false;
+function validateMessage(message) {
   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 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);
-
-    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;
+function publicAttachments(attachments) {
+  return attachments.map(({ name, size, type }) => ({ name, size, type }));
+}
+
+async function prepareComposer(client, options, timeoutMs) {
+  const selectedModel = options.model ? await selectModelFromClient(client, options.model) : null;
+  const attachments = options.attachments?.length
+    ? await uploadAttachmentsFromClient(client, options.attachments, { timeoutMs: Math.min(timeoutMs, 60_000) })
+    : [];
+  return { selectedModel, attachments };
+}
+
+async function sendFromClient(client, requestedId, message, options, prepared) {
+  const { selectedModel, attachments } = prepared;
+  const timeoutMs = options.timeoutMs || 120_000;
+  const waitForReply = options.waitForReply || false;
+  const before = await readFromClient(client);
+  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 (attachments.length) {
+    while (Date.now() < deadline && !attachmentsConfirmed(before, messages, attachments)) {
       await delay(250);
+      messages = await readFromClient(client);
     }
-    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, ...(selectedModel ? { model: selectedModel.name } : {}), sent, reply: null };
+    if (!attachmentsConfirmed(before, messages, attachments)) {
+      throw new Error(`Doubao did not confirm the sent attachments within ${timeoutMs} ms`);
     }
+  }
 
-    let stableText = '';
-    let stablePolls = 0;
-    while (Date.now() < deadline) {
-      messages = await readFromClient(client);
-      const reply = replyAfterLastUserMessage(messages, message);
-      const generating = await client.evaluate(`[
-        ...document.querySelectorAll('[data-testid="chat_input_local_break_button"], [data-testid="chat_input_end_button"]'),
-      ].some((element) => {
-        const style = getComputedStyle(element);
-        const rect = element.getBoundingClientRect();
-        return style.display !== 'none'
-          && style.visibility !== 'hidden'
-          && Number(style.opacity) !== 0
-          && rect.width > 0
-          && rect.height > 0;
-      })`);
-      if (reply?.text && reply.text === stableText && !generating) stablePolls += 1;
-      else stablePolls = 0;
-      stableText = reply?.text || '';
-      if (reply && stablePolls >= 2) {
-        return { conversationId: id, ...(selectedModel ? { model: selectedModel.name } : {}), sent, reply };
-      }
-      await delay(500);
+  const conversationId = requestedId || await waitForConversationId(client, Math.min(5000, Math.max(1, deadline - Date.now())));
+  const baseResult = {
+    conversationId,
+    ...(selectedModel ? { model: selectedModel.name } : {}),
+    ...(attachments.length ? { attachments: publicAttachments(attachments) } : {}),
+    sent,
+  };
+  if (!waitForReply) return { ...baseResult, reply: null };
+
+  let stableText = '';
+  let stablePolls = 0;
+  while (Date.now() < deadline) {
+    messages = await readFromClient(client);
+    const reply = replyAfterLastUserMessage(messages, message);
+    const generating = await client.evaluate(`[
+      ...document.querySelectorAll('[data-testid="chat_input_local_break_button"], [data-testid="chat_input_end_button"]'),
+    ].some((element) => {
+      const style = getComputedStyle(element);
+      const rect = element.getBoundingClientRect();
+      return style.display !== 'none'
+        && style.visibility !== 'hidden'
+        && Number(style.opacity) !== 0
+        && rect.width > 0
+        && rect.height > 0;
+    })`);
+    if (reply?.text && reply.text === stableText && !generating) stablePolls += 1;
+    else stablePolls = 0;
+    stableText = reply?.text || '';
+    if (reply && stablePolls >= 2) return { ...baseResult, reply };
+    await delay(500);
+  }
+  throw new Error(`Doubao reply did not complete within ${timeoutMs} ms`);
+}
+
+export async function sendMessage(id, message, options = {}) {
+  const timeoutMs = options.timeoutMs || 120_000;
+  const deadline = Date.now() + timeoutMs;
+  validateMessage(message);
+
+  openConversation(id);
+  return withChatClient(async (client) => {
+    await waitForConversation(client, id, Math.min(remainingMilliseconds(deadline, timeoutMs), 15_000));
+    const prepared = await prepareComposer(client, options, remainingMilliseconds(deadline, timeoutMs));
+    return sendFromClient(client, id, message, {
+      ...options,
+      timeoutMs: remainingMilliseconds(deadline, timeoutMs),
+    }, prepared);
+  });
+}
+
+export async function createConversation(message, options = {}) {
+  const timeoutMs = options.timeoutMs || 120_000;
+  const deadline = Date.now() + timeoutMs;
+  const hasMessage = typeof message === 'string' && message.length > 0;
+  if (hasMessage) validateMessage(message);
+
+  return withChatClient(async (client) => {
+    const createSelector = await client.evaluate(`document.querySelector(${JSON.stringify(CREATE_BUTTON)})
+      ? ${JSON.stringify(CREATE_BUTTON)}
+      : document.querySelector(${JSON.stringify(CREATE_OFFICE_TASK)}) ? ${JSON.stringify(CREATE_OFFICE_TASK)} : null`);
+    if (!createSelector) throw new Error('Doubao new conversation button was not found');
+    await client.click(createSelector);
+    const route = await waitForBlankConversation(client, Math.min(remainingMilliseconds(deadline, timeoutMs), 15_000));
+    const prepared = await prepareComposer(client, options, remainingMilliseconds(deadline, timeoutMs));
+    if (!hasMessage) {
+      return {
+        conversationId: null,
+        created: true,
+        persisted: false,
+        route,
+        ...(prepared.selectedModel ? { model: prepared.selectedModel.name } : {}),
+        ...(prepared.attachments.length ? { attachments: publicAttachments(prepared.attachments) } : {}),
+      };
     }
-    throw new Error(`Doubao reply did not complete within ${timeoutMs} ms`);
+    const result = await sendFromClient(client, null, message, {
+      ...options,
+      timeoutMs: remainingMilliseconds(deadline, timeoutMs),
+    }, prepared);
+    return { ...result, created: true, persisted: true };
   });
 }

package/src/cdp.mjs

@@ -140,7 +140,7 @@ export class CdpClient {
 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.`);
+    throw new Error(`Doubao CDP is unavailable at ${endpoint}. Run "doubao cdp launch" to restart Doubao with CDP enabled.`);
   }
   const target = await findChatTarget(endpoint);
   const client = await new CdpClient(target.webSocketDebuggerUrl).connect();

package/src/cli.mjs

@@ -1,9 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
 import { currentSession, getDataDir, listSessions, resolveProfile } from './storage.mjs';
 import { cdpStatus } from './cdp.mjs';
-import { openConversation, readConversation, sendMessage } from './automation.mjs';
+import { createConversation, openConversation, readConversation, sendMessage } from './automation.mjs';
 import { currentModel, listModels, selectModel } from './models.mjs';
 
 const DEFAULT_APP = '/Applications/Doubao.app';
@@ -14,14 +15,15 @@ const HELP = `Usage:
   doubao profiles [--json]
   doubao sessions list [--profile <name>] [--json]
   doubao sessions current [--profile <name>] [--json]
+  doubao sessions create [message] [--attach <path>] [--model <model>] [--wait] [--timeout <seconds>] [--json]
   doubao sessions open <conversation-id>
   doubao sessions read <conversation-id> [--limit <count>] [--json]
-  doubao sessions send <conversation-id> <message> [--model <model>] [--wait] [--timeout <seconds>] [--json]
+  doubao sessions send <conversation-id> <message> [--attach <path>] [--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 cdp launch [--yes] [--json]
   doubao capabilities [--json]
 
 Environment:
@@ -30,17 +32,24 @@ Environment:
   DOUBAO_CDP_ENDPOINT  CDP endpoint (default: http://127.0.0.1:9225)
 `;
 
-function parseOptions(argv) {
+export function parseOptions(argv) {
   const args = [];
   let profile;
   let json = false;
+  let yes = false;
   let wait = false;
   let timeoutSeconds = 120;
   let limit = 20;
   let model;
+  const attachments = [];
   for (let index = 0; index < argv.length; index += 1) {
-    if (argv[index] === '--json') {
+    if (argv[index] === '--') {
+      args.push(...argv.slice(index + 1));
+      break;
+    } else if (argv[index] === '--json') {
       json = true;
+    } else if (argv[index] === '--yes') {
+      yes = true;
     } else if (argv[index] === '--wait') {
       wait = true;
     } else if (argv[index] === '--profile') {
@@ -59,11 +68,16 @@ function parseOptions(argv) {
       model = argv[index + 1];
       if (!model) throw new Error('--model requires a value');
       index += 1;
+    } else if (argv[index] === '--attach') {
+      const attachment = argv[index + 1];
+      if (!attachment || attachment.startsWith('--')) throw new Error('--attach requires a file path');
+      attachments.push(attachment);
+      index += 1;
     } else {
       args.push(argv[index]);
     }
   }
-  return { args, profile, json, wait, timeoutMs: timeoutSeconds * 1000, limit, model };
+  return { args, profile, json, yes, wait, timeoutMs: timeoutSeconds * 1000, limit, model, attachments };
 }
 
 function output(value, json) {
@@ -79,9 +93,71 @@ function appVersion(appPath) {
   return result.status === 0 ? result.stdout.trim() : null;
 }
 
-function appRunning(appPath) {
+function appProcessPattern(appPath) {
   const executable = path.join(appPath, 'Contents', 'MacOS', 'Doubao');
-  return spawnSync('/usr/bin/pgrep', ['-f', executable]).status === 0;
+  const escaped = executable.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+  return `^${escaped}([[:space:]]|$)`;
+}
+
+function appRunning(appPath) {
+  return spawnSync('/usr/bin/pgrep', ['-f', appProcessPattern(appPath)]).status === 0;
+}
+
+async function waitForAppExit(appPath, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!appRunning(appPath)) return true;
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  return !appRunning(appPath);
+}
+
+async function quitAppForCdp(appPath) {
+  const result = spawnSync('/usr/bin/osascript', [
+    '-e',
+    'tell application id "com.bot.pc.doubao" to quit',
+  ], { encoding: 'utf8' });
+  if (result.status === 0 && await waitForAppExit(appPath, 5000)) return;
+
+  const terminated = spawnSync('/usr/bin/pkill', ['-TERM', '-f', appProcessPattern(appPath)], { encoding: 'utf8' });
+  if (terminated.status !== 0 && terminated.status !== 1) {
+    throw new Error(terminated.stderr.trim() || result.stderr.trim() || 'failed to stop Doubao before enabling CDP');
+  }
+  if (!await waitForAppExit(appPath, 10_000)) {
+    throw new Error('Doubao did not quit after SIGTERM. Quit it manually, then run "doubao cdp launch" again.');
+  }
+}
+
+async function confirmCdpRestart({ json, yes }) {
+  if (yes) return;
+  if (json || !process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error('Doubao must restart to enable CDP. Re-run "doubao cdp launch --yes" to confirm.');
+  }
+
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = await prompt.question('Doubao must restart to enable CDP. Continue? [y/N] ');
+    if (!/^(?:y|yes)$/iu.test(answer.trim())) {
+      throw new Error('CDP launch cancelled; Doubao was not restarted.');
+    }
+  } finally {
+    prompt.close();
+  }
+}
+
+async function waitForAutomationReady(timeoutMs = 20_000) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const result = await listModels();
+      if (result.models.length) return;
+    } catch (error) {
+      lastError = error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  throw new Error(`Doubao CDP is listening, but the chat renderer is not ready: ${lastError?.message || 'timed out'}`);
 }
 
 function validateId(value) {
@@ -94,7 +170,7 @@ function sessionWithTitle(profilePath, id) {
 }
 
 export async function main(argv) {
-  const { args, profile: requestedProfile, json, wait, timeoutMs, limit, model } = parseOptions(argv);
+  const { args, profile: requestedProfile, json, yes, wait, timeoutMs, limit, model, attachments } = parseOptions(argv);
   const [command, subcommand, operand] = args;
   const dataDir = getDataDir();
 
@@ -127,8 +203,10 @@ export async function main(argv) {
       listSessions: true,
       detectCurrentSession: true,
       openSession: true,
+      createSessions: cdp.available,
       readMessages: cdp.available,
       sendMessages: cdp.available,
+      uploadAttachments: cdp.available,
       selectModels: cdp.available,
       cdp,
       note: cdp.available
@@ -141,8 +219,10 @@ export async function main(argv) {
       console.log('sessions list\tyes');
       console.log('sessions current\tyes');
       console.log('sessions open\tyes');
+      console.log(`sessions create\t${capabilities.createSessions ? 'yes' : 'no'}`);
       console.log(`messages read\t${capabilities.readMessages ? 'yes' : 'no'}`);
       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(`note\t${capabilities.note}`);
     }
@@ -199,17 +279,22 @@ export async function main(argv) {
   if (command === 'cdp' && subcommand === 'launch') {
     const existing = await cdpStatus();
     if (existing.available) {
+      await waitForAutomationReady();
       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 restarted = appRunning(appPath);
+    if (restarted) {
+      await confirmCdpRestart({ json, yes });
+      await quitAppForCdp(appPath);
+    }
     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;
@@ -218,8 +303,10 @@ export async function main(argv) {
       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}`);
+    await waitForAutomationReady();
+    const launchResult = { ...launched, launched: true, restarted };
+    if (json) output(launchResult, true);
+    else console.log(`available\tyes\nendpoint\t${launched.endpoint}\nrestarted\t${restarted ? 'yes' : 'no'}`);
     return;
   }
 
@@ -269,6 +356,25 @@ export async function main(argv) {
     return;
   }
 
+  if (subcommand === 'create') {
+    const message = args.slice(2).join(' ');
+    const result = await createConversation(message, {
+      attachments,
+      model,
+      timeoutMs,
+      waitForReply: wait,
+    });
+    if (json) output(result, true);
+    else {
+      console.log(`created\t${result.conversationId || 'draft'}`);
+      if (result.model) console.log(`model\t${result.model}`);
+      for (const attachment of result.attachments || []) console.log(`attachment\t${attachment.name}`);
+      if (result.sent) console.log(`sent\t${result.sent.text}`);
+      if (result.reply) console.log(`reply\t${result.reply.text.replaceAll('\n', '\\n')}`);
+    }
+    return;
+  }
+
   if (subcommand === 'open') {
     const id = validateId(operand);
     const url = openConversation(id);
@@ -288,11 +394,12 @@ 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, model });
+    const result = await sendMessage(id, message, { attachments, 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}`);
+      for (const attachment of result.attachments || []) console.log(`attachment\t${attachment.name}`);
       if (result.reply) console.log(`reply\t${result.reply.text.replaceAll('\n', '\\n')}`);
     }
     return;