doubao-cli 0.3.0 → 0.4.0

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
@@ -45,7 +48,35 @@ Quit any running Doubao process first, then run `doubao cdp launch`. The equival
 
 Set `DOUBAO_CDP_ENDPOINT` if using another port. `sessions send --wait` waits for and returns the completed assistant reply.
 
-`models` reads the choices currently exposed by the desktop app. `model select` changes the active model, and `sessions send --model` selects a model before sending. Exact display names and these aliases are supported: `auto`, `turbo`, `pro`, `orange`, `gemini`, `gpt`, `sol`, plus the stable ids printed by `doubao models`.
+### 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 |
+| --- | --- | --- |
+| 自动 | `auto` | `自动` |
+| 豆包 2.1 Turbo | `doubao-2.1-turbo` | `turbo` |
+| 豆包 2.1 Pro | `doubao-2.1-pro` | `pro` |
+| Orange 5.0 | `orange-5.0` | `orange` |
+| Gemini 3.7 Flash | `gemini-3.7-flash` | `gemini` |
+| GPT-5.6 Sol | `gpt-5.6-sol` | `gpt`, `sol` |
+
+Use the value, exact display name, or a short alias anywhere `<model>` is accepted. Run `doubao models` to verify the choices exposed by the installed Doubao version.
 
 CDP is unauthenticated but bound to `127.0.0.1`. Quit and relaunch Doubao normally when automation is no longer needed.
 
@@ -55,12 +86,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.0",
+  "version": "0.4.0",
   "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/cli.mjs

@@ -3,7 +3,7 @@ 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';
+import { createConversation, openConversation, readConversation, sendMessage } from './automation.mjs';
 import { currentModel, listModels, selectModel } from './models.mjs';
 
 const DEFAULT_APP = '/Applications/Doubao.app';
@@ -14,9 +14,10 @@ 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]
@@ -30,7 +31,7 @@ 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;
@@ -38,8 +39,12 @@ function parseOptions(argv) {
   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] === '--wait') {
       wait = true;
@@ -59,11 +64,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, wait, timeoutMs: timeoutSeconds * 1000, limit, model, attachments };
 }
 
 function output(value, json) {
@@ -94,7 +104,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, wait, timeoutMs, limit, model, attachments } = parseOptions(argv);
   const [command, subcommand, operand] = args;
   const dataDir = getDataDir();
 
@@ -127,8 +137,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 +153,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}`);
     }
@@ -269,6 +283,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 +321,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;