dingding-local-api-mcp 1.3.8

package/README.md

@@ -0,0 +1,36 @@
+# dingding-local-api-mcp
+
+MCP stdio server for DingDing Browser Local API.
+
+## Install
+
+```bash
+npm install -g dingding-local-api-mcp
+```
+
+## Codex
+
+```bash
+codex mcp add --env DDB_PORT="19876" --env DDB_API_KEY="your_api_key" dingding-local-api -- npx -y dingding-local-api-mcp
+```
+
+## Claude Code
+
+```bash
+claude mcp add dingding-local-api -e DDB_PORT="19876" -e DDB_API_KEY="your_api_key" -- npx -y dingding-local-api-mcp
+```
+
+Tools include:
+
+- `check_status`
+- `list_profiles`
+- `create_profile`
+- `open_browser`
+- `close_browser`
+- `get_runtime_session`
+- `list_automation_scripts`
+- `run_automation_script`
+- `list_groups`
+- `list_proxies`
+- `list_tags`
+- `list_cores`

package/bin/dingding-local-api-mcp.cjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+'use strict'
+
+const { runServer } = require('../src/server.cjs')
+
+runServer().catch((err) => {
+  process.stderr.write(`[dingding-local-api-mcp] ${err && err.stack ? err.stack : err}\n`)
+  process.exitCode = 1
+})

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "dingding-local-api-mcp",
+  "version": "1.3.8",
+  "description": "MCP stdio server for DingDing Browser Local API.",
+  "license": "MIT",
+  "main": "src/server.cjs",
+  "bin": {
+    "dingding-local-api-mcp": "bin/dingding-local-api-mcp.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/dingding-local-api-mcp.cjs && node --check src/server.cjs"
+  }
+}

package/src/server.cjs

@@ -0,0 +1,287 @@
+'use strict'
+
+const { createClient } = loadCore()
+
+const VERSION = '1.3.8'
+
+const TOOL_DEFINITIONS = [
+  tool('check_status', 'Check DingDing Browser Local API availability.', {}),
+  tool('list_profiles', 'List browser profiles.', {}),
+  tool('get_profile', 'Get one browser profile by profileId.', { profileId: stringProp('Profile ID') }, ['profileId']),
+  tool('create_profile', 'Create a browser profile. Body matches POST /api/profiles.', { profile: objectProp('Profile input'), launchCode: stringProp('Launch code'), autoLaunch: boolProp('Auto launch after create'), start: objectProp('One-time start options') }, ['profile']),
+  tool('update_profile', 'Update a browser profile. Body matches PUT /api/profiles/{profileId}.', { profileId: stringProp('Profile ID'), profile: objectProp('Profile input'), launchCode: stringProp('Launch code'), autoLaunch: boolProp('Auto launch after update'), start: objectProp('One-time start options') }, ['profileId', 'profile']),
+  tool('delete_profile', 'Delete a stopped browser profile.', { profileId: stringProp('Profile ID') }, ['profileId']),
+  tool('open_browser', 'Open or launch a browser profile by selector.', selectorProps()),
+  tool('get_runtime_active', 'Get the active runtime target.', {}),
+  tool('get_runtime_session', 'Open and wait for a debuggable runtime session.', { ...selectorProps(), timeoutMs: intProp('Wait timeout in milliseconds') }),
+  tool('get_runtime_status', 'Get runtime status by selector without launching.', selectorProps()),
+  tool('close_browser', 'Stop a browser profile by selector.', selectorProps()),
+  tool('list_launch_logs', 'List recent Launch API call logs.', { limit: intProp('Max records') }),
+  tool('list_automation_scripts', 'List automation scripts.', {}),
+  tool('get_automation_script', 'Get automation script metadata by scriptId.', { scriptId: stringProp('Script ID') }, ['scriptId']),
+  tool('run_automation_script', 'Run an automation script.', { scriptId: stringProp('Script ID'), selector: objectProp('Target selector'), params: objectProp('Script params'), useScriptSelector: boolProp('Use default selector'), useScriptParams: boolProp('Use default params'), timeoutMs: intProp('Timeout in milliseconds') }, ['scriptId']),
+  tool('list_automation_runs', 'List recent automation script runs.', { limit: intProp('Max records') }),
+  tool('list_groups', 'List profile groups.', {}),
+  tool('create_group', 'Create a profile group.', { groupName: stringProp('Group name'), parentId: stringProp('Parent group ID'), sortOrder: intProp('Sort order') }, ['groupName']),
+  tool('update_group', 'Update a profile group.', { groupId: stringProp('Group ID'), groupName: stringProp('Group name'), parentId: stringProp('Parent group ID'), sortOrder: intProp('Sort order') }, ['groupId']),
+  tool('delete_group', 'Delete a profile group.', { groupId: stringProp('Group ID') }, ['groupId']),
+  tool('move_profiles_to_group', 'Move profiles to a group.', { groupId: stringProp('Group ID'), profileIds: arrayProp('Profile IDs') }, ['groupId', 'profileIds']),
+  tool('list_proxies', 'List proxy pool nodes.', { groupName: stringProp('Filter by proxy group name') }),
+  tool('list_proxy_groups', 'List proxy group names.', {}),
+  tool('get_proxy', 'Get one proxy pool node.', { proxyId: stringProp('Proxy ID') }, ['proxyId']),
+  tool('create_proxy', 'Append one proxy or a proxy list to the proxy pool.', { proxy: objectProp('Single proxy object'), proxies: arrayProp('Proxy list') }),
+  tool('update_proxy', 'Update one proxy pool node.', { proxyId: stringProp('Proxy ID'), proxy: objectProp('Proxy object') }, ['proxyId', 'proxy']),
+  tool('delete_proxy', 'Delete one proxy pool node.', { proxyId: stringProp('Proxy ID') }, ['proxyId']),
+  tool('list_tags', 'List all tags used by profiles.', {}),
+  tool('rename_tag', 'Rename a tag across profiles.', { oldName: stringProp('Old tag name'), newName: stringProp('New tag name') }, ['oldName', 'newName']),
+  tool('set_tags', 'Batch set or append tags for profiles.', { profileIds: arrayProp('Profile IDs'), tags: arrayProp('Tags'), replace: boolProp('Replace existing tags') }, ['profileIds', 'tags']),
+  tool('remove_tags', 'Batch remove tags from profiles.', { profileIds: arrayProp('Profile IDs'), tags: arrayProp('Tags') }, ['profileIds', 'tags']),
+  tool('list_cores', 'List installed browser cores.', {}),
+]
+
+async function callTool(name, args = {}, client = createClient()) {
+  switch (name) {
+    case 'check_status':
+      return client.health()
+    case 'list_profiles':
+      return client.listProfiles()
+    case 'get_profile':
+      return client.getProfile(args.profileId)
+    case 'create_profile':
+      return client.createProfile(pick(args, ['profile', 'launchCode', 'autoLaunch', 'start']))
+    case 'update_profile':
+      return client.updateProfile(args.profileId, pick(args, ['profile', 'launchCode', 'autoLaunch', 'start']))
+    case 'delete_profile':
+      return client.deleteProfile(args.profileId)
+    case 'open_browser':
+      return client.launch(args)
+    case 'get_runtime_active':
+      return client.runtimeActive()
+    case 'get_runtime_session':
+      return client.runtimeSession(args)
+    case 'get_runtime_status':
+      return client.runtimeStatus(args)
+    case 'close_browser':
+      return client.runtimeStop(args)
+    case 'list_launch_logs':
+      return client.launchLogs(args.limit)
+    case 'list_automation_scripts':
+      return client.listAutomationScripts()
+    case 'get_automation_script':
+      return client.getAutomationScript(args.scriptId)
+    case 'run_automation_script':
+      return client.runAutomationScript(pick(args, ['scriptId', 'selector', 'params', 'useScriptSelector', 'useScriptParams', 'timeoutMs']))
+    case 'list_automation_runs':
+      return client.listAutomationRuns(args.limit)
+    case 'list_groups':
+      return client.listGroups()
+    case 'create_group':
+      return client.createGroup(pick(args, ['groupName', 'parentId', 'sortOrder']))
+    case 'update_group':
+      return client.updateGroup(args.groupId, pick(args, ['groupName', 'parentId', 'sortOrder']))
+    case 'delete_group':
+      return client.deleteGroup(args.groupId)
+    case 'move_profiles_to_group':
+      return client.moveProfilesToGroup(args.groupId, args.profileIds)
+    case 'list_proxies':
+      return client.listProxies(args.groupName)
+    case 'list_proxy_groups':
+      return client.listProxyGroups()
+    case 'get_proxy':
+      return client.getProxy(args.proxyId)
+    case 'create_proxy':
+      return client.createProxy(args.proxies || args.proxy)
+    case 'update_proxy':
+      return client.updateProxy(args.proxyId, args.proxy)
+    case 'delete_proxy':
+      return client.deleteProxy(args.proxyId)
+    case 'list_tags':
+      return client.listTags()
+    case 'rename_tag':
+      return client.renameTag(args.oldName, args.newName)
+    case 'set_tags':
+      return client.setTags(args.profileIds, args.tags, args.replace)
+    case 'remove_tags':
+      return client.removeTags(args.profileIds, args.tags)
+    case 'list_cores':
+      return client.listCores()
+    default:
+      throw new Error(`unknown tool: ${name}`)
+  }
+}
+
+function runServer(input = process.stdin, output = process.stdout) {
+  const client = createClient()
+  let buffer = Buffer.alloc(0)
+
+  input.on('data', (chunk) => {
+    buffer = Buffer.concat([buffer, chunk])
+    while (true) {
+      const parsed = readMessage(buffer)
+      if (!parsed) return
+      buffer = parsed.rest
+      handleMessage(parsed.message, client)
+        .then((response) => {
+          if (response) writeMessage(output, response)
+        })
+        .catch((err) => {
+          if (parsed.message && parsed.message.id !== undefined) {
+            writeMessage(output, errorResponse(parsed.message.id, -32603, err.message || String(err)))
+          }
+        })
+    }
+  })
+
+  return Promise.resolve()
+}
+
+async function handleMessage(message, client) {
+  if (!message || message.id === undefined) return null
+  switch (message.method) {
+    case 'initialize':
+      return resultResponse(message.id, {
+        protocolVersion: (message.params && message.params.protocolVersion) || '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'dingding-local-api-mcp', version: VERSION },
+      })
+    case 'ping':
+      return resultResponse(message.id, {})
+    case 'tools/list':
+      return resultResponse(message.id, { tools: TOOL_DEFINITIONS })
+    case 'tools/call':
+      return handleToolCall(message, client)
+    case 'shutdown':
+      return resultResponse(message.id, null)
+    default:
+      return errorResponse(message.id, -32601, `method not found: ${message.method}`)
+  }
+}
+
+async function handleToolCall(message, client) {
+  const params = message.params || {}
+  try {
+    const data = await callTool(params.name, params.arguments || {}, client)
+    return resultResponse(message.id, {
+      content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+      isError: false,
+    })
+  } catch (err) {
+    const payload = { ok: false, error: err.message || String(err) }
+    if (err.status) payload.status = err.status
+    if (err.payload !== undefined) payload.payload = err.payload
+    return resultResponse(message.id, {
+      content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+      isError: true,
+    })
+  }
+}
+
+function readMessage(buffer) {
+  const sep = buffer.indexOf('\r\n\r\n')
+  if (sep < 0) return null
+  const header = buffer.subarray(0, sep).toString('utf8')
+  const match = /content-length:\s*(\d+)/i.exec(header)
+  if (!match) throw new Error('missing Content-Length header')
+  const length = Number(match[1])
+  const start = sep + 4
+  const end = start + length
+  if (buffer.length < end) return null
+  const raw = buffer.subarray(start, end).toString('utf8')
+  return {
+    message: JSON.parse(raw),
+    rest: buffer.subarray(end),
+  }
+}
+
+function writeMessage(output, message) {
+  const body = Buffer.from(JSON.stringify(message), 'utf8')
+  output.write(`Content-Length: ${body.length}\r\n\r\n`)
+  output.write(body)
+}
+
+function resultResponse(id, result) {
+  return { jsonrpc: '2.0', id, result }
+}
+
+function errorResponse(id, code, message) {
+  return { jsonrpc: '2.0', id, error: { code, message } }
+}
+
+function tool(name, description, properties, required = []) {
+  return {
+    name,
+    description,
+    inputSchema: {
+      type: 'object',
+      properties,
+      required,
+      additionalProperties: false,
+    },
+  }
+}
+
+function selectorProps() {
+  return {
+    selector: objectProp('Nested selector object'),
+    code: stringProp('Launch code'),
+    key: stringProp('Alias for launch code'),
+    profileId: stringProp('Profile ID'),
+    profileName: stringProp('Profile name'),
+    keyword: stringProp('Keyword'),
+    keywords: arrayProp('Keywords'),
+    tag: stringProp('Tag'),
+    tags: arrayProp('Tags'),
+    groupId: stringProp('Group ID'),
+    matchMode: stringProp('unique, first, or all depending on endpoint'),
+    startUrls: arrayProp('One-time start URLs'),
+    skipDefaultStartUrls: boolProp('Skip configured start URLs'),
+    launchArgs: arrayProp('One-time launch args'),
+    proxyId: stringProp('One-time proxy ID'),
+    proxyConfig: stringProp('One-time proxy config'),
+  }
+}
+
+function stringProp(description) {
+  return { type: 'string', description }
+}
+
+function boolProp(description) {
+  return { type: 'boolean', description }
+}
+
+function intProp(description) {
+  return { type: 'integer', description }
+}
+
+function objectProp(description) {
+  return { type: 'object', description, additionalProperties: true }
+}
+
+function arrayProp(description) {
+  return { type: 'array', description, items: {} }
+}
+
+function pick(source, keys) {
+  const out = {}
+  for (const key of keys) {
+    if (source[key] !== undefined) out[key] = source[key]
+  }
+  return out
+}
+
+function loadCore() {
+  try {
+    return require('dingding-local-api-core')
+  } catch {
+    return require('../../dingding-local-api-core/src/index.cjs')
+  }
+}
+
+module.exports = {
+  TOOL_DEFINITIONS,
+  callTool,
+  handleMessage,
+  readMessage,
+  runServer,
+  writeMessage,
+}