@agentrhq/webcmd 0.1.1 → 0.2.0

package/clis/trae-cn/ask.js

@@ -1,99 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { TimeoutError } from '@agentrhq/webcmd/errors';
-import {
-  activityScript,
-  approveTraePrompts,
-  isActivityComplete,
-  isLikelyBlockingActivity,
-  latestAssistantScript,
-  normalizeApprovalKinds,
-  normalizeMaxChars,
-  normalizeTimeout,
-  sendTraePrompt,
-} from './utils.js';
-
-function normalizeAutoApprove(value) {
-  return value === true || String(value).toLowerCase() === 'true';
-}
-
-export const askCommand = cli({
-  site: 'trae-cn',
-  name: 'ask',
-  access: 'write',
-  description: 'Send a prompt to Trae CN, wait for the assistant result without treating approval cards as final, and return it',
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 WEBCMD_CDP_TARGET=talk webcmd trae-cn ask "请只回复 OK" --timeout 120 -f json',
-  domain: 'localhost',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [
-    { name: 'text', required: true, positional: true, help: 'Prompt to send into Trae CN' },
-    { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait for response (default: 60)', default: 60 },
-    { name: 'max-chars', type: 'int', required: false, help: 'Max chars to return from the assistant response; 0 returns full text (default: 12000)', default: 12000 },
-    { name: 'auto-approve', type: 'boolean', required: false, help: 'While waiting, approve visible terminal/delete prompts, including high-risk terminal confirmation layers (default: false)', default: false },
-    { name: 'approve-kinds', type: 'string', required: false, help: 'Comma-separated approval categories for --auto-approve: terminal,delete,keep,all (default: terminal,delete; keep is not default)', default: 'terminal,delete' },
-  ],
-  columns: ['Role', 'Text', 'TextChars', 'Truncated', 'TurnIndex', 'MessageId'],
-  func: async (page, kwargs) => {
-    const timeout = normalizeTimeout(kwargs.timeout, 60);
-    const maxChars = normalizeMaxChars(kwargs['max-chars'], 12000);
-    const autoApprove = normalizeAutoApprove(kwargs['auto-approve']);
-    const approvalKinds = normalizeApprovalKinds(kwargs['approve-kinds']);
-    const beforeAssistant = await page.evaluate(latestAssistantScript(0));
-    const beforeKey = [
-      beforeAssistant?.MessageId || '',
-      beforeAssistant?.TurnIndex || '',
-      beforeAssistant?.Text || '',
-    ].join('|');
-    await sendTraePrompt(page, kwargs.text);
-
-    const deadline = Date.now() + timeout * 1000;
-    let lastText = '';
-    let stableSince = 0;
-    let latest = null;
-    let latestActivity = null;
-
-    while (Date.now() < deadline) {
-      await page.wait(2);
-      if (autoApprove) {
-        await approveTraePrompts(page, approvalKinds, { click: true, limit: 1, maxChars: 600 });
-      }
-      latest = await page.evaluate(latestAssistantScript(maxChars));
-      latestActivity = await page.evaluate(activityScript(600));
-      const text = latest?.Text?.trim() || '';
-      if (!text) continue;
-      const latestKey = [
-        latest?.MessageId || '',
-        latest?.TurnIndex || '',
-        latest?.Text || '',
-      ].join('|');
-      if (latestKey === beforeKey) continue;
-      if (text !== lastText) {
-        lastText = text;
-        stableSince = Date.now();
-        continue;
-      }
-      const stableFor = Date.now() - stableSince;
-      const blocked = isLikelyBlockingActivity(latestActivity);
-      const completed = isActivityComplete(latestActivity);
-      if (completed && !blocked && stableFor >= 1000) {
-        return [latest];
-      }
-      if (!blocked && stableFor >= 3000) {
-        return [latest];
-      }
-    }
-
-    if (latest?.Text) {
-      const blocked = isLikelyBlockingActivity(latestActivity);
-      if (blocked) {
-        throw new TimeoutError(
-          'trae-cn ask',
-          timeout,
-          `Current status=${latestActivity?.Status ?? ''}, approvalPending=${latestActivity?.ApprovalPending ?? ''}, approvalKind=${latestActivity?.ApprovalKind ?? ''}, approvalButton=${latestActivity?.ApprovalButton ?? ''}. Use "webcmd trae-cn targets -f json" to find the waiting target, then run "WEBCMD_CDP_TARGET=<target> webcmd trae-cn watch --stream true --duration 300" or "webcmd trae-cn approve".`,
-        );
-      }
-      return [latest];
-    }
-    throw new TimeoutError('trae-cn ask', timeout, 'No Trae CN response was visible before the timeout. The agent may still be generating.');
-  },
-});

package/clis/trae-cn/dump.js

@@ -1,5 +0,0 @@
-import { makeDumpCommand } from '../_shared/desktop-commands.js';
-
-export const dumpCommand = makeDumpCommand('trae-cn', {
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 WEBCMD_CDP_TARGET=talk webcmd trae-cn dump -f json',
-});

package/clis/trae-cn/export.js

@@ -1,40 +0,0 @@
-import * as fs from 'node:fs';
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { normalizeLimit, readTraeMessages } from './utils.js';
-
-export const exportCommand = cli({
-  site: 'trae-cn',
-  name: 'export',
-  access: 'read',
-  description: 'Export the current Trae CN conversation to Markdown',
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 WEBCMD_CDP_TARGET=talk webcmd trae-cn export --limit 20 --output /tmp/trae-cn-export.md',
-  domain: 'localhost',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [
-    { name: 'output', required: false, help: 'Output file (default: /tmp/trae-cn-export.md)' },
-    { name: 'limit', type: 'int', required: false, help: 'Max recent turns to export (default: 50)', default: 50 },
-  ],
-  columns: ['Status', 'File', 'Messages'],
-  func: async (page, kwargs) => {
-    const outputPath = kwargs.output || '/tmp/trae-cn-export.md';
-    const limit = normalizeLimit(kwargs.limit, 50);
-    const messages = await readTraeMessages(page, limit);
-    const markdown = [
-      '# Trae CN Conversation Export',
-      '',
-      ...messages.map((message, index) => [
-        `## ${index + 1}. ${message.Role}`,
-        '',
-        message.Text,
-        '',
-      ].join('\n')),
-    ].join('\n');
-    fs.writeFileSync(outputPath, markdown);
-    return [{
-      Status: 'Success',
-      File: outputPath,
-      Messages: messages.length,
-    }];
-  },
-});

package/clis/trae-cn/model.js

@@ -1,22 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { inspectTraeShellScript } from './utils.js';
-
-export const modelCommand = cli({
-  site: 'trae-cn',
-  name: 'model',
-  access: 'read',
-  description: 'Read the model label currently shown in the Trae CN chat input',
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 WEBCMD_CDP_TARGET=talk webcmd trae-cn model -f json',
-  domain: 'localhost',
-  strategy: Strategy.UI,
-  browser: true,
-  columns: ['Model', 'Agent', 'Workspace'],
-  func: async (page) => {
-    const info = await page.evaluate(inspectTraeShellScript());
-    return [{
-      Model: info.model || '',
-      Agent: info.agent || '',
-      Workspace: info.workspace || '',
-    }];
-  },
-});

package/clis/trae-cn/new.js

@@ -1,63 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { CommandExecutionError, selectorError } from '@agentrhq/webcmd/errors';
-import { clickNewTaskScript, currentTaskStateScript, ensurePrompt, normalizeTimeout, sendTraePrompt } from './utils.js';
-
-export const newCommand = cli({
-  site: 'trae-cn',
-  name: 'new',
-  access: 'write',
-  description: 'Start a new Trae CN task in the current workspace, optionally sending the first prompt',
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 WEBCMD_CDP_TARGET=talk webcmd trae-cn new "请执行你的任务" -f json',
-  domain: 'localhost',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [
-    { name: 'prompt', required: false, positional: true, help: 'Optional first prompt to send after creating the task' },
-    { name: 'timeout', type: 'int', required: false, help: 'Max seconds to wait for a fresh task composer (default: 10)', default: 10 },
-  ],
-  columns: ['Status', 'Action', 'Workspace', 'Model', 'Agent', 'FreshTaskConfirmed', 'TurnsBeforeSubmit', 'Turns', 'ComposerReady', 'SubmitMode'],
-  func: async (page, kwargs) => {
-    const timeout = normalizeTimeout(kwargs.timeout, 10);
-    const clicked = await page.evaluate(clickNewTaskScript());
-    if (!clicked?.ok) {
-      throw selectorError('Trae CN new task button');
-    }
-
-    const started = Date.now();
-    let state = null;
-    while (Date.now() - started < timeout * 1000) {
-      await page.wait(0.5);
-      state = await page.evaluate(currentTaskStateScript());
-      if (state?.composerReady && state.turns === 0) break;
-    }
-
-    if (!state?.composerReady || state.turns !== 0) {
-      throw new CommandExecutionError(
-        `Clicked Trae CN new task via ${clicked.method}; fresh empty composer was not confirmed`,
-        `Observed composerReady=${state?.composerReady ? 'yes' : 'no'}, turns=${state?.turns ?? 'unavailable'}. Verify the current window is a Trae CN chat workspace and retry.`,
-      );
-    }
-
-    const turnsBeforeSubmit = state.turns;
-    let submitMode = '';
-    if (kwargs.prompt !== undefined && kwargs.prompt !== null && String(kwargs.prompt).trim()) {
-      const result = await sendTraePrompt(page, ensurePrompt(kwargs.prompt));
-      submitMode = result.mode;
-      await page.wait(0.5);
-      state = await page.evaluate(currentTaskStateScript());
-    }
-
-    return [{
-      Status: 'Success',
-      Action: kwargs.prompt ? `New task created via ${clicked.method}; prompt submitted` : `New task created via ${clicked.method}`,
-      Workspace: state?.workspace || '',
-      Model: state?.model || '',
-      Agent: state?.agent || '',
-      FreshTaskConfirmed: 'yes',
-      TurnsBeforeSubmit: turnsBeforeSubmit,
-      Turns: state?.turns ?? 0,
-      ComposerReady: state?.composerReady ? 'yes' : 'no',
-      SubmitMode: submitMode,
-    }];
-  },
-});

package/clis/trae-cn/read.js

@@ -1,23 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { normalizeLimit, normalizeMaxChars, readTraeMessages } from './utils.js';
-
-export const readCommand = cli({
-  site: 'trae-cn',
-  name: 'read',
-  access: 'read',
-  description: 'Read the current Trae CN chat conversation',
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 WEBCMD_CDP_TARGET=talk webcmd trae-cn read --limit 5 --max-chars 12000 -f json',
-  domain: 'localhost',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [
-    { name: 'limit', type: 'int', required: false, help: 'Max recent turns to return (default: 20)', default: 20 },
-    { name: 'max-chars', type: 'int', required: false, help: 'Max chars per turn; 0 returns full text (default: 6000)', default: 6000 },
-  ],
-  columns: ['Role', 'Text', 'TextChars', 'Truncated', 'TurnIndex', 'MessageId'],
-  func: async (page, kwargs) => {
-    const limit = normalizeLimit(kwargs.limit, 20);
-    const maxChars = normalizeMaxChars(kwargs['max-chars'], 6000);
-    return readTraeMessages(page, limit, maxChars);
-  },
-});

package/clis/trae-cn/screenshot.js

@@ -1,5 +0,0 @@
-import { makeScreenshotCommand } from '../_shared/desktop-commands.js';
-
-export const screenshotTraeCn = makeScreenshotCommand('trae-cn', 'Trae CN', {
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 WEBCMD_CDP_TARGET=talk webcmd trae-cn screenshot --output /tmp/trae-cn-snapshot.txt',
-});

package/clis/trae-cn/select-model.js

@@ -1,25 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { selectTraeModel } from './utils.js';
-
-export const selectModelCommand = cli({
-  site: 'trae-cn',
-  name: 'select-model',
-  access: 'write',
-  description: 'Select a model in the current Trae CN chat input',
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 WEBCMD_CDP_TARGET=talk webcmd trae-cn select-model "GPT 5.4" -f json',
-  domain: 'localhost',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [{ name: 'name', required: true, positional: true, help: 'Model label, for example GPT 5.4 or GPT-5.4' }],
-  columns: ['Status', 'Requested', 'Selected', 'Workspace', 'Agent'],
-  func: async (page, kwargs) => {
-    const result = await selectTraeModel(page, kwargs.name);
-    return [{
-      Status: 'Success',
-      Requested: result.requested,
-      Selected: result.selected,
-      Workspace: result.workspace,
-      Agent: result.agent,
-    }];
-  },
-});

package/clis/trae-cn/send.js

@@ -1,23 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { sendTraePrompt } from './utils.js';
-
-export const sendCommand = cli({
-  site: 'trae-cn',
-  name: 'send',
-  access: 'write',
-  description: 'Send a prompt into the current Trae CN chat input',
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 WEBCMD_CDP_TARGET=talk webcmd trae-cn send "请执行你的任务" -f json',
-  domain: 'localhost',
-  strategy: Strategy.UI,
-  browser: true,
-  args: [{ name: 'text', required: true, positional: true, help: 'Text to send into Trae CN' }],
-  columns: ['Status', 'InjectedText', 'SubmitMode'],
-  func: async (page, kwargs) => {
-    const result = await sendTraePrompt(page, kwargs.text);
-    return [{
-      Status: 'Success',
-      InjectedText: result.prompt,
-      SubmitMode: result.mode,
-    }];
-  },
-});

package/clis/trae-cn/setup.js

@@ -1,75 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-
-export const setupCommand = cli({
-  site: 'trae-cn',
-  name: 'setup',
-  access: 'read',
-  description: 'Show local setup commands for controlling Trae CN with Webcmd',
-  example: 'webcmd trae-cn setup -f table',
-  strategy: Strategy.LOCAL,
-  browser: false,
-  args: [],
-  columns: ['Step', 'Command', 'Purpose'],
-  func: async () => [
-    {
-      Step: '1. Launch Trae CN with CDP',
-      Command: 'open -a "Trae CN" --args --remote-debugging-port=39240',
-      Purpose: 'Start Trae CN with a Chrome DevTools Protocol endpoint',
-    },
-    {
-      Step: '2. Point Webcmd at Trae',
-      Command: 'export WEBCMD_CDP_ENDPOINT="http://127.0.0.1:39240"',
-      Purpose: 'Tell Webcmd which local Trae CDP endpoint to use',
-    },
-    {
-      Step: '3. Select a workspace target',
-      Command: 'export WEBCMD_CDP_TARGET="talk"',
-      Purpose: 'Choose the Trae workspace/window title when multiple targets are open',
-    },
-    {
-      Step: '4. List Trae targets',
-      Command: 'webcmd trae-cn targets -f table',
-      Purpose: 'Find the right workspace target and spot windows with ApprovalPending=yes',
-    },
-    {
-      Step: '5. Verify connection',
-      Command: 'webcmd trae-cn status -f json',
-      Purpose: 'Confirm workspace, model, agent, turn count, and composer readiness',
-    },
-    {
-      Step: '6. Start a fresh task',
-      Command: 'webcmd trae-cn new "请执行你的任务" -f json',
-      Purpose: 'Create a new task and send the first prompt',
-    },
-    {
-      Step: '7. Monitor progress',
-      Command: 'webcmd trae-cn watch --stream true --duration 120',
-      Purpose: 'Read in-app running/completed state as JSONL without approving terminal/delete confirmations',
-    },
-    {
-      Step: '8. Approve blockers when needed',
-      Command: 'webcmd trae-cn approve --approve-kinds terminal,delete -f json',
-      Purpose: 'Click visible Trae prompts for terminal command or delete confirmations',
-    },
-    {
-      Step: '9. Opt in to auto-approve when needed',
-      Command: 'webcmd trae-cn watch --stream true --duration 120 --auto-approve true',
-      Purpose: 'Explicitly opt in when you want watch to approve terminal/delete prompts while monitoring',
-    },
-    {
-      Step: '10. Read result',
-      Command: 'webcmd trae-cn read --limit 5 --max-chars 12000 -f json',
-      Purpose: 'Fetch recent user/assistant turns from the current task',
-    },
-    {
-      Step: 'Auto-run boundary',
-      Command: 'rm, mv, chmod, dd, truncate, kill, destructive git/database commands',
-      Purpose: 'Trae CN may still stop these as high-risk even when command mode is 自动运行; Webcmd approves them only after explicit --auto-approve true or approve',
-    },
-    {
-      Step: 'Help',
-      Command: 'webcmd trae-cn --help -f yaml',
-      Purpose: 'Get all Trae CN commands, args, examples, and output columns in structured form',
-    },
-  ],
-});

package/clis/trae-cn/status.js

@@ -1,27 +0,0 @@
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { inspectTraeShellScript } from './utils.js';
-
-export const statusCommand = cli({
-  site: 'trae-cn',
-  name: 'status',
-  access: 'read',
-  description: 'Check active CDP connection to Trae CN and summarize the current workspace/model',
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 WEBCMD_CDP_TARGET=talk webcmd trae-cn status -f json',
-  domain: 'localhost',
-  strategy: Strategy.UI,
-  browser: true,
-  columns: ['Status', 'Title', 'Workspace', 'Model', 'Agent', 'Turns', 'ComposerReady', 'Url'],
-  func: async (page) => {
-    const info = await page.evaluate(inspectTraeShellScript());
-    return [{
-      Status: 'Connected',
-      Title: info.title || '',
-      Workspace: info.workspace || '',
-      Model: info.model || '',
-      Agent: info.agent || '',
-      Turns: info.turns ?? 0,
-      ComposerReady: info.composerReady ? 'yes' : 'no',
-      Url: info.url || '',
-    }];
-  },
-});

package/clis/trae-cn/targets.js

@@ -1,96 +0,0 @@
-import { CDPBridge } from '@agentrhq/webcmd/browser/cdp';
-import { ArgumentError } from '@agentrhq/webcmd/errors';
-import { cli, Strategy } from '@agentrhq/webcmd/registry';
-import { activityScript } from './utils.js';
-
-function normalizeEndpoint(value) {
-  const endpoint = String(value || process.env.WEBCMD_CDP_ENDPOINT || 'http://127.0.0.1:39240').trim();
-  if (!endpoint) {
-    throw new ArgumentError('Set WEBCMD_CDP_ENDPOINT, for example http://127.0.0.1:39240');
-  }
-  return endpoint.replace(/\/$/, '');
-}
-
-function normalizeBoolean(value, fallback = true) {
-  if (value === undefined || value === null) return fallback;
-  return value === true || String(value).toLowerCase() === 'true';
-}
-
-function targetValue(target) {
-  const title = String(target?.title || '').trim();
-  const workspace = title.match(/—\s*(.+)$/)?.[1]?.trim();
-  return workspace || title || String(target?.url || '').trim();
-}
-
-function matchesTarget(target, wanted) {
-  if (!wanted) return false;
-  const needle = String(wanted).toLowerCase();
-  const haystack = `${target.title || ''} ${target.url || ''}`.toLowerCase();
-  return haystack.includes(needle);
-}
-
-async function fetchTargets(endpoint) {
-  const response = await fetch(`${endpoint}/json`, { signal: AbortSignal.timeout(5000) });
-  if (!response.ok) {
-    throw new Error(`Failed to fetch CDP targets: HTTP ${response.status}`);
-  }
-  const targets = await response.json();
-  return Array.isArray(targets) ? targets : [];
-}
-
-async function probeTargetActivity(target, maxChars) {
-  if (!target.webSocketDebuggerUrl) return null;
-  const bridge = new CDPBridge();
-  try {
-    const page = await bridge.connect({ cdpEndpoint: target.webSocketDebuggerUrl, timeout: 3, surface: 'adapter' });
-    return await page.evaluate(activityScript(maxChars));
-  } catch {
-    return null;
-  } finally {
-    await bridge.close().catch(() => {});
-  }
-}
-
-export const targetsCommand = cli({
-  site: 'trae-cn',
-  name: 'targets',
-  access: 'read',
-  description: 'List Trae CN CDP targets and show which workspace/window is waiting',
-  example: 'WEBCMD_CDP_ENDPOINT=http://127.0.0.1:39240 webcmd trae-cn targets -f table',
-  strategy: Strategy.LOCAL,
-  browser: false,
-  args: [
-    { name: 'endpoint', type: 'string', required: false, help: 'CDP endpoint (default: WEBCMD_CDP_ENDPOINT)' },
-    { name: 'probe-activity', type: 'boolean', required: false, help: 'Probe each target for Trae activity state (default: true)', default: true },
-    { name: 'max-chars', type: 'int', required: false, help: 'Max chars for approval prompt/activity snippets (default: 240)', default: 240 },
-  ],
-  columns: ['Index', 'SelectedHint', 'RecommendedTarget', 'Title', 'Workspace', 'Status', 'ApprovalPending', 'ApprovalKind', 'ApprovalButton', 'Model', 'Agent', 'Type', 'Url'],
-  func: async (kwargs) => {
-    const endpoint = normalizeEndpoint(kwargs.endpoint);
-    const probe = normalizeBoolean(kwargs['probe-activity'], true);
-    const maxChars = Number.isInteger(Number(kwargs['max-chars'])) ? Number(kwargs['max-chars']) : 240;
-    const wanted = process.env.WEBCMD_CDP_TARGET || '';
-    const targets = (await fetchTargets(endpoint)).filter(target => target.webSocketDebuggerUrl && target.type !== 'worker');
-    const rows = [];
-
-    for (const [index, target] of targets.entries()) {
-      const activity = probe ? await probeTargetActivity(target, maxChars) : null;
-      rows.push({
-        Index: index,
-        SelectedHint: wanted ? (matchesTarget(target, wanted) ? 'yes' : 'no') : (index === 0 ? 'default' : ''),
-        RecommendedTarget: targetValue(target),
-        Title: target.title || '',
-        Workspace: activity?.Workspace || target.title?.match(/—\s*(.+)$/)?.[1]?.trim() || '',
-        Status: activity?.Status || '',
-        ApprovalPending: activity?.ApprovalPending || '',
-        ApprovalKind: activity?.ApprovalKind || '',
-        ApprovalButton: activity?.ApprovalButton || '',
-        Model: activity?.Model || '',
-        Agent: activity?.Agent || '',
-        Type: target.type || '',
-        Url: target.url || '',
-      });
-    }
-    return rows;
-  },
-});