dingding-browser 1.3.8

package/README.md

@@ -0,0 +1,39 @@
+# dingding-browser
+
+DingDing Browser CLI for the local Launch API.
+
+## Install
+
+```bash
+npm install -g dingding-browser
+```
+
+Aliases:
+
+```bash
+dingding-browser
+dingding
+ddb
+```
+
+## Examples
+
+```bash
+ddb status
+ddb list-profiles
+ddb open BUYER_001
+ddb open 550e8400-e29b-41d4-a716-446655440000 --by profile-id
+ddb runtime-session BUYER_001 --timeout-ms 45000
+ddb close BUYER_001
+ddb list-proxies
+ddb create-proxy '{"proxyName":"US-1","proxyConfig":"http://127.0.0.1:8080"}'
+ddb list-scripts
+ddb run-script '{"scriptId":"news-query-txt","selector":{"code":"BUYER_001"},"params":{"keyword":"OpenAI"}}'
+```
+
+Connection:
+
+```bash
+ddb status --port 19876 --api-key "$DDB_API_KEY"
+ddb status --base-url http://127.0.0.1:19876
+```

package/bin/ddb.cjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+'use strict'
+
+const { run } = require('../src/cli.cjs')
+
+run(process.argv.slice(2)).catch((err) => {
+  const payload = {
+    ok: false,
+    error: err && err.message ? err.message : String(err),
+  }
+  if (err && err.status) payload.status = err.status
+  if (err && err.payload !== undefined) payload.payload = err.payload
+  process.stderr.write(`${JSON.stringify(payload, null, 2)}\n`)
+  process.exitCode = 1
+})

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "dingding-browser",
+  "version": "1.3.8",
+  "description": "DingDing Browser local automation CLI.",
+  "license": "MIT",
+  "main": "src/cli.cjs",
+  "bin": {
+    "dingding-browser": "bin/ddb.cjs",
+    "dingding": "bin/ddb.cjs",
+    "ddb": "bin/ddb.cjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "dependencies": {
+    "dingding-local-api-core": "1.3.8"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.cjs",
+    "check": "node --check bin/ddb.cjs && node --check src/cli.cjs"
+  }
+}

package/src/cli.cjs

@@ -0,0 +1,340 @@
+'use strict'
+
+const core = loadCore()
+const {
+  createClient,
+  parseJSONArg,
+  parseValueOrJSON,
+  selectorBodyFromValue,
+  trim,
+} = core
+
+const VERSION = '1.3.8'
+
+async function run(argv = process.argv.slice(2), io = process) {
+  const parsed = parseArgs(argv)
+  if (parsed.help || !parsed.command) {
+    write(io.stdout, helpText())
+    return
+  }
+  if (parsed.command === 'version' || parsed.command === '--version' || parsed.command === '-v') {
+    write(io.stdout, `${VERSION}\n`)
+    return
+  }
+
+  const client = createClient(parsed.options)
+  const result = await executeCommand(client, parsed.command, parsed.args, parsed.options)
+  if (parsed.options.raw) {
+    write(io.stdout, typeof result === 'string' ? `${result}\n` : `${JSON.stringify(result)}\n`)
+  } else {
+    write(io.stdout, `${JSON.stringify(result, null, 2)}\n`)
+  }
+}
+
+async function executeCommand(client, command, args, options = {}) {
+  switch (normalizeCommand(command)) {
+    case 'status':
+      return client.health()
+    case 'list-profiles':
+      return client.listProfiles()
+    case 'get-profile':
+      return client.getProfile(requiredArg(args, 0, 'profileId'))
+    case 'create-profile':
+      return client.createProfile(parseJSONArg(requiredArg(args, 0, 'request JSON'), 'create profile request'))
+    case 'update-profile': {
+      const first = requiredArg(args, 0, 'profileId or request JSON')
+      if (looksJSON(first)) {
+        const input = parseJSONArg(first, 'update profile request')
+        const profileId = input.profileId
+        delete input.profileId
+        return client.updateProfile(profileId, input)
+      }
+      return client.updateProfile(first, parseJSONArg(requiredArg(args, 1, 'request JSON'), 'update profile request'))
+    }
+    case 'delete-profile':
+      return client.deleteProfile(requiredArg(args, 0, 'profileId'))
+    case 'open-browser':
+      return client.launch(buildSelectorRequest(args, options))
+    case 'open-browser-by-code':
+      return client.launchByCode(requiredArg(args, 0, 'code'))
+    case 'runtime-active':
+      return client.runtimeActive()
+    case 'runtime-session':
+      return client.runtimeSession(buildSelectorRequest(args, options))
+    case 'runtime-status':
+      return client.runtimeStatus(buildSelectorRequest(args, options))
+    case 'close-browser':
+      return client.runtimeStop(buildSelectorRequest(args, options))
+    case 'launch-logs':
+      return client.launchLogs(args[0] || options.limit)
+    case 'list-scripts':
+      return client.listAutomationScripts()
+    case 'get-script':
+      return client.getAutomationScript(requiredArg(args, 0, 'scriptId'))
+    case 'run-script':
+      return client.runAutomationScript(buildRunScriptRequest(args))
+    case 'list-runs':
+      return client.listAutomationRuns(args[0] || options.limit)
+    case 'list-groups':
+      return client.listGroups()
+    case 'create-group':
+      return client.createGroup(parseJSONArg(requiredArg(args, 0, 'request JSON'), 'create group request'))
+    case 'update-group':
+      return client.updateGroup(requiredArg(args, 0, 'groupId'), parseJSONArg(requiredArg(args, 1, 'request JSON'), 'update group request'))
+    case 'delete-group':
+      return client.deleteGroup(requiredArg(args, 0, 'groupId'))
+    case 'move-profiles':
+      return client.moveProfilesToGroup(requiredArg(args, 0, 'groupId'), parseJSONArg(requiredArg(args, 1, 'profileIds JSON array'), 'profileIds'))
+    case 'list-proxies':
+      return client.listProxies(options.group || options.groupName || args[0])
+    case 'list-proxy-groups':
+      return client.listProxyGroups()
+    case 'get-proxy':
+      return client.getProxy(requiredArg(args, 0, 'proxyId'))
+    case 'create-proxy':
+      return client.createProxy(parseJSONArg(requiredArg(args, 0, 'proxy JSON or JSON array'), 'create proxy request'))
+    case 'save-proxies':
+      return client.saveProxies(parseJSONArg(requiredArg(args, 0, 'proxy list JSON'), 'save proxies request'))
+    case 'update-proxy':
+      return client.updateProxy(requiredArg(args, 0, 'proxyId'), parseJSONArg(requiredArg(args, 1, 'proxy JSON'), 'update proxy request'))
+    case 'delete-proxy':
+      return client.deleteProxy(requiredArg(args, 0, 'proxyId'))
+    case 'list-tags':
+      return client.listTags()
+    case 'rename-tag':
+      return client.renameTag(requiredArg(args, 0, 'oldName'), requiredArg(args, 1, 'newName'))
+    case 'set-tags':
+      return client.setTags(parseJSONArg(requiredArg(args, 0, 'profileIds JSON array'), 'profileIds'), parseJSONArg(requiredArg(args, 1, 'tags JSON array'), 'tags'), Boolean(options.replace))
+    case 'remove-tags':
+      return client.removeTags(parseJSONArg(requiredArg(args, 0, 'profileIds JSON array'), 'profileIds'), parseJSONArg(requiredArg(args, 1, 'tags JSON array'), 'tags'))
+    case 'list-cores':
+      return client.listCores()
+    default:
+      throw new Error(`unknown command: ${command}`)
+  }
+}
+
+function buildSelectorRequest(args, options) {
+  const first = requiredArg(args, 0, 'selector value or JSON')
+  const parsed = parseValueOrJSON(first)
+  const body = selectorBodyFromValue(parsed, options)
+  if (options.matchMode && !body.matchMode) body.matchMode = options.matchMode
+  if (options.startUrl) body.startUrls = Array.isArray(options.startUrl) ? options.startUrl : [options.startUrl]
+  if (options.skipDefaultStartUrls) body.skipDefaultStartUrls = true
+  if (options.timeoutMs) body.timeoutMs = Number(options.timeoutMs)
+  return body
+}
+
+function buildRunScriptRequest(args) {
+  const first = requiredArg(args, 0, 'scriptId or request JSON')
+  if (looksJSON(first)) return parseJSONArg(first, 'run script request')
+  const req = { scriptId: first }
+  if (args[1]) req.params = parseJSONArg(args[1], 'script params')
+  if (args[2]) req.selector = parseJSONArg(args[2], 'script selector')
+  return req
+}
+
+function parseArgs(argv) {
+  const options = {}
+  const args = []
+  let command = ''
+  let help = false
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i]
+    if (token === '-h' || token === '--help') {
+      help = true
+      continue
+    }
+    if (token === '--raw') {
+      options.raw = true
+      continue
+    }
+    if (token === '--replace') {
+      options.replace = true
+      continue
+    }
+    if (token === '--skip-default-start-urls') {
+      options.skipDefaultStartUrls = true
+      continue
+    }
+    if (token === '-p' || token === '--port') {
+      options.port = requiredNext(argv, ++i, token)
+      continue
+    }
+    if (token === '-b' || token === '--base-url') {
+      options.baseUrl = requiredNext(argv, ++i, token)
+      continue
+    }
+    if (token === '-k' || token === '--api-key') {
+      options.apiKey = requiredNext(argv, ++i, token)
+      continue
+    }
+    if (token === '--auth-header') {
+      options.authHeader = requiredNext(argv, ++i, token)
+      continue
+    }
+    if (token === '--by') {
+      options.by = requiredNext(argv, ++i, token)
+      continue
+    }
+    if (token === '--match-mode') {
+      options.matchMode = requiredNext(argv, ++i, token)
+      continue
+    }
+    if (token === '--start-url') {
+      options.startUrl = appendOption(options.startUrl, requiredNext(argv, ++i, token))
+      continue
+    }
+    if (token === '--timeout-ms') {
+      options.timeoutMs = requiredNext(argv, ++i, token)
+      continue
+    }
+    if (token === '--group' || token === '--group-name') {
+      options.groupName = requiredNext(argv, ++i, token)
+      continue
+    }
+    if (!command) {
+      command = token
+    } else {
+      args.push(token)
+    }
+  }
+
+  return { command, args, options, help }
+}
+
+function normalizeCommand(command) {
+  switch (command) {
+    case 'check-status':
+      return 'status'
+    case 'profiles':
+    case 'get-browser-list':
+    case 'list-browser':
+    case 'list-browsers':
+      return 'list-profiles'
+    case 'get-browser':
+      return 'get-profile'
+    case 'create-browser':
+      return 'create-profile'
+    case 'update-browser':
+      return 'update-profile'
+    case 'delete-browser':
+      return 'delete-profile'
+    case 'open':
+    case 'launch':
+      return 'open-browser'
+    case 'launch-code':
+      return 'open-browser-by-code'
+    case 'active':
+      return 'runtime-active'
+    case 'session':
+      return 'runtime-session'
+    case 'runtime':
+      return 'runtime-session'
+    case 'profile-status':
+    case 'get-browser-active':
+      return 'runtime-status'
+    case 'close':
+    case 'stop':
+    case 'close-browser':
+      return 'close-browser'
+    case 'scripts':
+      return 'list-scripts'
+    case 'runs':
+      return 'list-runs'
+    case 'groups':
+    case 'get-group-list':
+      return 'list-groups'
+    case 'proxies':
+    case 'get-proxy-list':
+      return 'list-proxies'
+    case 'proxy-groups':
+      return 'list-proxy-groups'
+    case 'tags':
+    case 'get-tag-list':
+      return 'list-tags'
+    case 'cores':
+    case 'get-kernel-list':
+      return 'list-cores'
+    default:
+      return command
+  }
+}
+
+function helpText() {
+  return `DingDing Browser CLI ${VERSION}
+
+Usage:
+  ddb <command> [arg] [--port 19876] [--api-key KEY]
+
+Core:
+  ddb status
+  ddb list-profiles
+  ddb open BUYER_001
+  ddb open 550e8400-e29b-41d4-a716-446655440000 --by profile-id
+  ddb close BUYER_001
+  ddb runtime-session BUYER_001 --timeout-ms 45000
+
+Profiles:
+  ddb get-profile <profileId>
+  ddb create-profile '{"profile":{"profileName":"buyer-001"},"launchCode":"BUYER_001"}'
+  ddb update-profile <profileId> '{"profile":{"profileName":"buyer-001"}}'
+  ddb delete-profile <profileId>
+
+Groups / Proxies / Tags / Cores:
+  ddb list-groups
+  ddb create-group '{"groupName":"Team A"}'
+  ddb list-proxies [groupName]
+  ddb create-proxy '{"proxyName":"US-1","proxyConfig":"http://127.0.0.1:8080"}'
+  ddb list-tags
+  ddb list-cores
+
+Automation:
+  ddb list-scripts
+  ddb run-script '{"scriptId":"news-query-txt","selector":{"code":"BUYER_001"},"params":{"keyword":"OpenAI"}}'
+`
+}
+
+function requiredArg(args, index, label) {
+  const value = trim(args[index])
+  if (!value) throw new Error(`${label} is required`)
+  return value
+}
+
+function requiredNext(argv, index, flag) {
+  const value = trim(argv[index])
+  if (!value) throw new Error(`${flag} requires a value`)
+  return value
+}
+
+function appendOption(current, value) {
+  if (!current) return value
+  if (Array.isArray(current)) return [...current, value]
+  return [current, value]
+}
+
+function looksJSON(value) {
+  const text = trim(value)
+  return text.startsWith('{') || text.startsWith('[')
+}
+
+function write(stream, text) {
+  if (stream && typeof stream.write === 'function') stream.write(text)
+}
+
+function loadCore() {
+  try {
+    return require('dingding-local-api-core')
+  } catch {
+    return require('../../dingding-local-api-core/src/index.cjs')
+  }
+}
+
+module.exports = {
+  executeCommand,
+  helpText,
+  normalizeCommand,
+  parseArgs,
+  run,
+}