dingding-local-api-core 1.3.8

package/README.md

@@ -0,0 +1,17 @@
+# dingding-local-api-core
+
+Shared Node.js client for DingDing Browser Local API.
+
+```js
+const { createClient } = require('dingding-local-api-core')
+
+const client = createClient({ port: 19876, apiKey: process.env.DDB_API_KEY })
+const profiles = await client.listProfiles()
+```
+
+Environment variables:
+
+- `DDB_BASE_URL` / `DINGDING_BASE_URL`
+- `DDB_PORT` / `DINGDING_PORT`
+- `DDB_API_KEY` / `DINGDING_API_KEY`
+- `DDB_AUTH_HEADER` / `DINGDING_AUTH_HEADER`

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "dingding-local-api-core",
+  "version": "1.3.8",
+  "description": "DingDing Browser Local API client for CLI and MCP integrations.",
+  "license": "MIT",
+  "main": "src/index.cjs",
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.cjs",
+    "check": "node --check src/index.cjs"
+  }
+}

package/src/index.cjs

@@ -0,0 +1,173 @@
+'use strict'
+
+const DEFAULT_PORT = 19876
+const DEFAULT_AUTH_HEADER = 'X-Ant-Api-Key'
+
+function normalizeBaseUrl(options = {}, env = process.env) {
+  const explicit = trim(options.baseUrl || env.DDB_BASE_URL || env.DINGDING_BASE_URL)
+  if (explicit) return explicit.replace(/\/+$/, '')
+
+  const rawPort = trim(options.port || env.DDB_PORT || env.DINGDING_PORT || env.PORT)
+  const port = rawPort || String(DEFAULT_PORT)
+  return `http://127.0.0.1:${port}`
+}
+
+function createClient(options = {}) {
+  const env = options.env || process.env
+  const baseUrl = normalizeBaseUrl(options, env)
+  const apiKey = trim(options.apiKey || env.DDB_API_KEY || env.DINGDING_API_KEY || env.API_KEY)
+  const authHeader = trim(options.authHeader || env.DDB_AUTH_HEADER || env.DINGDING_AUTH_HEADER || env.AUTH_HEADER) || DEFAULT_AUTH_HEADER
+  const fetchImpl = options.fetch || globalThis.fetch
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('global fetch is unavailable; DingDing CLI requires Node.js 18 or newer')
+  }
+
+  async function request(method, path, body, query) {
+    const url = new URL(path, baseUrl)
+    for (const [key, value] of Object.entries(query || {})) {
+      if (value === undefined || value === null || value === '') continue
+      url.searchParams.set(key, String(value))
+    }
+
+    const headers = { Accept: 'application/json' }
+    const init = { method, headers }
+    if (apiKey) headers[authHeader] = apiKey
+    if (body !== undefined) {
+      headers['Content-Type'] = 'application/json'
+      init.body = JSON.stringify(body)
+    }
+
+    const response = await fetchImpl(url, init)
+    const text = await response.text()
+    const payload = parseJSONText(text)
+    if (!response.ok) {
+      const message = payload && typeof payload === 'object' && payload.error ? payload.error : `HTTP ${response.status}`
+      const err = new Error(message)
+      err.status = response.status
+      err.payload = payload || text
+      throw err
+    }
+    return payload === undefined ? text : payload
+  }
+
+  return {
+    baseUrl,
+    authHeader,
+    request,
+    health: () => request('GET', '/api/health'),
+    listProfiles: () => request('GET', '/api/profiles'),
+    getProfile: (profileId) => request('GET', `/api/profiles/${encodeURIComponent(required(profileId, 'profileId'))}`),
+    createProfile: (input) => request('POST', '/api/profiles', input),
+    updateProfile: (profileId, input) => request('PUT', `/api/profiles/${encodeURIComponent(required(profileId, 'profileId'))}`, input),
+    deleteProfile: (profileId) => request('DELETE', `/api/profiles/${encodeURIComponent(required(profileId, 'profileId'))}`),
+    launch: (input) => request('POST', '/api/launch', input),
+    launchByCode: (code) => request('GET', `/api/launch/${encodeURIComponent(required(code, 'code'))}`),
+    launchLogs: (limit) => request('GET', '/api/launch/logs', undefined, { limit }),
+    runtimeActive: () => request('GET', '/api/runtime/active'),
+    runtimeSession: (input) => request('POST', '/api/runtime/session', input),
+    runtimeStatus: (input) => request('POST', '/api/runtime/status', input),
+    runtimeStop: (input) => request('POST', '/api/runtime/stop', input),
+    listAutomationScripts: () => request('GET', '/api/automation/scripts'),
+    getAutomationScript: (scriptId) => request('GET', `/api/automation/scripts/${encodeURIComponent(required(scriptId, 'scriptId'))}`),
+    runAutomationScript: (input) => request('POST', '/api/automation/scripts/run', input),
+    listAutomationRuns: (limit) => request('GET', '/api/automation/scripts/runs', undefined, { limit }),
+    listGroups: () => request('GET', '/api/groups'),
+    createGroup: (input) => request('POST', '/api/groups', input),
+    updateGroup: (groupId, input) => request('PUT', `/api/groups/${encodeURIComponent(required(groupId, 'groupId'))}`, input),
+    deleteGroup: (groupId) => request('DELETE', `/api/groups/${encodeURIComponent(required(groupId, 'groupId'))}`),
+    moveProfilesToGroup: (groupId, profileIds) => request('POST', `/api/groups/${encodeURIComponent(required(groupId, 'groupId'))}/profiles`, { profileIds }),
+    listProxies: (groupName) => request('GET', '/api/proxies', undefined, { groupName }),
+    listProxyGroups: () => request('GET', '/api/proxies/groups'),
+    getProxy: (proxyId) => request('GET', `/api/proxies/${encodeURIComponent(required(proxyId, 'proxyId'))}`),
+    createProxy: (input) => request('POST', '/api/proxies', input),
+    saveProxies: (items) => request('PUT', '/api/proxies', items),
+    updateProxy: (proxyId, input) => request('PUT', `/api/proxies/${encodeURIComponent(required(proxyId, 'proxyId'))}`, input),
+    deleteProxy: (proxyId) => request('DELETE', `/api/proxies/${encodeURIComponent(required(proxyId, 'proxyId'))}`),
+    listTags: () => request('GET', '/api/tags'),
+    renameTag: (oldName, newName) => request('POST', '/api/tags/rename', { oldName, newName }),
+    setTags: (profileIds, tags, replace = false) => request('POST', '/api/tags/set', { profileIds, tags, replace }),
+    removeTags: (profileIds, tags) => request('POST', '/api/tags/remove', { profileIds, tags }),
+    listCores: () => request('GET', '/api/cores'),
+  }
+}
+
+function selectorBodyFromValue(value, options = {}) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) return value
+  const field = selectorFieldName(options.by || options.selector || 'code')
+  return { [field]: required(value, field) }
+}
+
+function selectorFieldName(input) {
+  const normalized = trim(input).toLowerCase().replace(/[_\s]+/g, '-')
+  switch (normalized) {
+    case 'profile-id':
+    case 'profileid':
+    case 'id':
+      return 'profileId'
+    case 'profile-name':
+    case 'profilename':
+    case 'name':
+      return 'profileName'
+    case 'group-id':
+    case 'groupid':
+      return 'groupId'
+    case 'keyword':
+    case 'tag':
+    case 'key':
+    case 'code':
+      return normalized
+    default:
+      throw new Error(`unsupported selector field: ${input}`)
+  }
+}
+
+function parseJSONArg(raw, label = 'argument') {
+  const text = trim(raw)
+  if (!text) return {}
+  try {
+    return JSON.parse(text)
+  } catch (err) {
+    throw new Error(`${label} must be valid JSON: ${err.message}`)
+  }
+}
+
+function parseValueOrJSON(raw) {
+  const text = trim(raw)
+  if (!text) return {}
+  if (text.startsWith('{') || text.startsWith('[')) return parseJSONArg(text)
+  return text
+}
+
+function parseJSONText(text) {
+  const body = trim(text)
+  if (!body) return undefined
+  try {
+    return JSON.parse(body)
+  } catch {
+    return undefined
+  }
+}
+
+function required(value, name) {
+  const out = trim(value)
+  if (!out) throw new Error(`${name} is required`)
+  return out
+}
+
+function trim(value) {
+  if (value === undefined || value === null) return ''
+  return String(value).trim()
+}
+
+module.exports = {
+  DEFAULT_AUTH_HEADER,
+  DEFAULT_PORT,
+  createClient,
+  normalizeBaseUrl,
+  parseJSONArg,
+  parseValueOrJSON,
+  required,
+  selectorBodyFromValue,
+  selectorFieldName,
+  trim,
+}