@larktask/aamp-feishu-task-agent 0.1.0-dev.174 → 0.1.1-dev.3

package/bin/runtime-concurrency.mjs

@@ -0,0 +1,71 @@
+export async function settleWithConcurrency(items, limit, worker) {
+  if (!Number.isInteger(limit) || limit < 1) throw new Error('concurrency limit must be a positive integer')
+  const results = new Array(items.length)
+  let cursor = 0
+  const run = async () => {
+    while (cursor < items.length) {
+      const index = cursor
+      cursor += 1
+      try {
+        results[index] = { status: 'fulfilled', value: await worker(items[index], index) }
+      } catch (reason) {
+        results[index] = { status: 'rejected', reason }
+      }
+    }
+  }
+  await Promise.all(Array.from(
+    { length: Math.min(limit, items.length) },
+    () => run(),
+  ))
+  return results
+}
+
+export async function runLayeredStarts(items, { prepare, start, concurrency }) {
+  const outcomes = new Array(items.length)
+  const prepared = []
+  for (let index = 0; index < items.length; index += 1) {
+    try {
+      prepared.push({ index, value: await prepare(items[index], index) })
+    } catch (reason) {
+      outcomes[index] = { status: 'rejected', phase: 'prepare', reason, item: items[index], index }
+    }
+  }
+  const started = await settleWithConcurrency(
+    prepared,
+    concurrency,
+    ({ index, value }) => start(value, index, items[index]),
+  )
+  started.forEach((result, preparedIndex) => {
+    const { index } = prepared[preparedIndex]
+    outcomes[index] = { ...result, phase: 'start', item: items[index], index }
+  })
+  return outcomes
+}
+
+export function createKeyedSerialExecutor() {
+  const tails = new Map()
+  return async (key, operation) => {
+    const previous = tails.get(key) || Promise.resolve()
+    const current = previous.catch(() => {}).then(operation)
+    tails.set(key, current)
+    try {
+      return await current
+    } finally {
+      if (tails.get(key) === current) tails.delete(key)
+    }
+  }
+}
+
+export function createSerializedRunner(operation) {
+  let tail = Promise.resolve()
+  return {
+    run() {
+      const current = tail.catch(() => {}).then(operation)
+      tail = current
+      return current
+    },
+    flush() {
+      return tail
+    },
+  }
+}

package/bin/runtime-network.mjs

@@ -190,6 +190,19 @@ export function agentStartRetryError(events, expectedAgentNames, attempt, maxAtt
   return undefined;
 }
 
+export function preserveAgentStartFailure(error, events) {
+  const failure = error instanceof Error ? error : new Error(String(error));
+  failure.agentStartEvents = [...(events || [])];
+  return failure;
+}
+
+export function agentStartFailureMessage(events, agentName, fallbackMessage) {
+  const failed = [...(events || [])]
+    .reverse()
+    .find((event) => event?.type === 'agent.failed' && event.agent === agentName);
+  return String(failed?.message || fallbackMessage || `${agentName} Agent Bridge 启动失败`);
+}
+
 export function safeDiagnosticUrl(rawUrl) {
   const parsed = new URL(rawUrl);
   parsed.username = '';

package/bin/runtime-package-executable.mjs

@@ -0,0 +1,254 @@
+import { spawn } from 'node:child_process'
+
+const NPM_EXEC_ENVIRONMENT_KEYS = [
+  'npm_lifecycle_event',
+  'npm_package_json',
+  'npm_command',
+  'npm_execpath',
+  'npm_node_execpath',
+  'INIT_CWD',
+]
+
+const RESOLVE_EXECUTABLE_SOURCE = String.raw`
+import fs from 'node:fs'
+import path from 'node:path'
+
+const executable = process.argv[1]
+const environmentKeys = ${JSON.stringify(NPM_EXEC_ENVIRONMENT_KEYS)}
+
+function environmentValue(name) {
+  return Object.entries(process.env)
+    .find(([key]) => key.toLowerCase() === name.toLowerCase())?.[1] || ''
+}
+
+const pathValue = environmentValue('PATH')
+const pathEntries = pathValue.split(path.delimiter).filter(Boolean)
+const environment = {}
+for (const key of environmentKeys) {
+  if (Object.hasOwn(process.env, key) && typeof process.env[key] === 'string') {
+    environment[key] = process.env[key]
+  }
+}
+const windowsExtensions = (environmentValue('PATHEXT') || '.COM;.EXE;.BAT;.CMD')
+  .split(';')
+  .map((extension) => extension.trim())
+  .filter(Boolean)
+
+function executableCandidates(binDir) {
+  const candidate = path.join(binDir, executable)
+  if (process.platform !== 'win32') return [candidate]
+  if (windowsExtensions.some((extension) => executable.toLowerCase().endsWith(extension.toLowerCase()))) {
+    return [candidate]
+  }
+  return windowsExtensions.map((extension) => candidate + extension.toLowerCase())
+}
+
+for (const binDir of pathEntries) {
+  for (const candidate of executableCandidates(binDir)) {
+    try {
+      const stat = fs.statSync(candidate)
+      if (!stat.isFile()) continue
+      if (process.platform !== 'win32') fs.accessSync(candidate, fs.constants.X_OK)
+      const extension = path.extname(candidate).toLowerCase()
+      const kind = process.platform === 'win32' && (extension === '.cmd' || extension === '.bat')
+        ? 'cmd'
+        : 'direct'
+      process.stdout.write(JSON.stringify({
+        executable,
+        kind,
+        command: candidate,
+        pathValue,
+        environment,
+      }))
+      process.exit(0)
+    } catch {
+      // Keep following npm's PATH order until its executable shim is found.
+    }
+  }
+}
+
+process.stderr.write('unable to resolve npm executable shim: ' + executable + '\\n')
+process.exit(1)
+`
+
+export function npmExecutableResolverArgs(executable) {
+  return ['--input-type=module', '--eval', RESOLVE_EXECUTABLE_SOURCE, executable]
+}
+
+function validatePreparedExecutable(value, executable = value?.executable) {
+  if (!value || typeof value !== 'object') {
+    throw new Error(`${executable || 'package'} resolved an invalid npm executable descriptor`)
+  }
+  if (value.executable !== executable || !['direct', 'cmd'].includes(value.kind)) {
+    throw new Error(`${executable} resolved an invalid npm executable descriptor`)
+  }
+  if (typeof value.command !== 'string' || !value.command) {
+    throw new Error(`${executable} resolved an invalid npm executable command`)
+  }
+  if (typeof value.pathValue !== 'string' || !value.pathValue) {
+    throw new Error(`${executable} resolved an invalid npm executable PATH`)
+  }
+  if (!value.environment || typeof value.environment !== 'object' || Array.isArray(value.environment)) {
+    throw new Error(`${executable} resolved an invalid npm executable environment`)
+  }
+  const environment = {}
+  for (const [key, environmentValue] of Object.entries(value.environment)) {
+    if (!NPM_EXEC_ENVIRONMENT_KEYS.includes(key) || typeof environmentValue !== 'string') {
+      throw new Error(`${executable} resolved an invalid npm executable environment`)
+    }
+    environment[key] = environmentValue
+  }
+  return {
+    executable: value.executable,
+    kind: value.kind,
+    command: value.command,
+    pathValue: value.pathValue,
+    environment,
+  }
+}
+
+export function parseResolvedPackageExecutable(stdout, executable) {
+  const lines = String(stdout || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
+  for (const line of lines.reverse()) {
+    try {
+      const result = JSON.parse(line)
+      if (result?.executable === executable) return validatePreparedExecutable(result, executable)
+    } catch {
+      // npm can print unrelated output; continue looking for the resolver record.
+    }
+  }
+  throw new Error(`${executable} package did not expose a runnable npm executable shim`)
+}
+
+function replacePath(environment, pathValue, platform) {
+  const next = { ...(environment || process.env) }
+  const existingKeys = Object.keys(next).filter((key) => key.toLowerCase() === 'path')
+  const pathKey = existingKeys[0] || (platform === 'win32' ? 'Path' : 'PATH')
+  for (const key of existingKeys) {
+    if (key !== pathKey) delete next[key]
+  }
+  next[pathKey] = pathValue
+  return next
+}
+
+function mergePreparedEnvironment(environment, descriptor, platform) {
+  const next = replacePath(environment, descriptor.pathValue, platform)
+  for (const [key, value] of Object.entries(descriptor.environment)) {
+    for (const existingKey of Object.keys(next)) {
+      if (existingKey.toLowerCase() === key.toLowerCase()) delete next[existingKey]
+    }
+    next[key] = value
+  }
+  return next
+}
+
+// Adapted from the escaping used by @npmcli/promise-spawn for cmd.exe. User
+// arguments need two escaping passes because a generated .cmd shim adds a
+// second cmd.exe parsing layer.
+function escapeCmdArgument(input, doubleEscape = false) {
+  const value = String(input)
+  if (!value.length) return '""'
+  let result
+  if (!/[ \t\n\v"]/.test(value)) {
+    result = value
+  } else {
+    result = '"'
+    for (let index = 0; index <= value.length; index += 1) {
+      let slashCount = 0
+      while (value[index] === '\\') {
+        index += 1
+        slashCount += 1
+      }
+      if (index === value.length) {
+        result += '\\'.repeat(slashCount * 2)
+        break
+      }
+      if (value[index] === '"') {
+        result += '\\'.repeat(slashCount * 2 + 1)
+        result += value[index]
+      } else {
+        result += '\\'.repeat(slashCount)
+        result += value[index]
+      }
+    }
+    result += '"'
+  }
+  result = result.replace(/[ !%^&()<>|"]/g, '^$&')
+  if (doubleEscape) result = result.replace(/[ !%^&()<>|"]/g, '^$&')
+  return result
+}
+
+export function createPackageExecutableLauncher({
+  materialize,
+  spawnProcess = spawn,
+  platform = process.platform,
+} = {}) {
+  if (typeof materialize !== 'function') throw new Error('materialize must be a function')
+  const resolved = new Map()
+  const packageTails = new Map()
+
+  function resolve(packageSpec, executable, context = {}) {
+    const key = JSON.stringify([packageSpec, executable])
+    const existing = resolved.get(key)
+    if (existing) return existing
+
+    const previous = packageTails.get(packageSpec) || Promise.resolve()
+    const pending = previous.catch(() => {}).then(async () => (
+      validatePreparedExecutable(
+        await materialize(packageSpec, executable, context),
+        executable,
+      )
+    ))
+    packageTails.set(packageSpec, pending)
+    resolved.set(key, pending)
+    pending.then(
+      () => {
+        if (packageTails.get(packageSpec) === pending) packageTails.delete(packageSpec)
+      },
+      () => {
+        if (resolved.get(key) === pending) resolved.delete(key)
+        if (packageTails.get(packageSpec) === pending) packageTails.delete(packageSpec)
+      },
+    )
+    return pending
+  }
+
+  function launchPrepared({ preparedExecutable, args = [], spawnOptions = {} }) {
+    const descriptor = validatePreparedExecutable(preparedExecutable)
+    const options = {
+      ...spawnOptions,
+      env: mergePreparedEnvironment(spawnOptions.env, descriptor, platform),
+      shell: false,
+    }
+    if (descriptor.kind === 'direct') {
+      return spawnProcess(descriptor.command, args, options)
+    }
+    if (platform !== 'win32') {
+      throw new Error(`${descriptor.executable} resolved a Windows command shim on ${platform}`)
+    }
+    const commandShell = Object.entries(options.env)
+      .find(([key]) => key.toLowerCase() === 'comspec')?.[1] || 'cmd.exe'
+    const script = [
+      escapeCmdArgument(descriptor.command),
+      ...args.map((argument) => escapeCmdArgument(argument, true)),
+    ].join(' ')
+    return spawnProcess(commandShell, ['/d', '/s', '/c', script], {
+      ...options,
+      windowsVerbatimArguments: true,
+    })
+  }
+
+  async function launch({
+    packageSpec,
+    executable,
+    args = [],
+    context = {},
+    spawnOptions = {},
+    preparedExecutable,
+  }) {
+    const descriptor = preparedExecutable || await resolve(packageSpec, executable, context)
+    return launchPrepared({ preparedExecutable: descriptor, args, spawnOptions })
+  }
+
+  return { launch, launchPrepared, resolve }
+}

package/bin/traecode-readiness.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+import { pathToFileURL } from 'node:url'
+
+const MAX_OUTPUT_BYTES = 1024 * 1024
+const EXIT = Object.freeze({ unsupported: 3, model: 10, blocked: 11, invalid: 65, execution: 70, timeout: 124, missing: 127 })
+
+function cleanText(value, homeDir = '') {
+  if (typeof value !== 'string') return undefined
+  let text = value.replace(/\s+/g, ' ').trim()
+  if (homeDir) text = text.split(homeDir).join('~')
+  if (!text) return undefined
+  return text.slice(0, 400)
+}
+
+export function supportsTraeCodeAcpHelp(output) {
+  const text = String(output || '')
+  return /\bacp\s+serve\b/i.test(text) && /Start the ACP server/i.test(text)
+}
+
+export function parseTraeCodeDoctor(raw, homeDir = '') {
+  let document
+  try {
+    document = JSON.parse(String(raw || ''))
+  } catch {
+    throw new Error('TraeCode doctor did not return valid JSON')
+  }
+  if (!document || typeof document !== 'object' || !Array.isArray(document.checks)) {
+    throw new Error('TraeCode doctor JSON is missing a checks array')
+  }
+
+  const checks = document.checks.map((value, index) => {
+    if (!value || typeof value !== 'object') {
+      throw new Error(`TraeCode doctor check ${index} is invalid`)
+    }
+    const name = cleanText(value.name, homeDir)
+    const severity = cleanText(value.severity, homeDir)?.toLowerCase()
+    const message = cleanText(value.message, homeDir)
+    const fix = cleanText(value.fix, homeDir)
+    if (!name || !['info', 'warning', 'error'].includes(severity) || !message) {
+      throw new Error(`TraeCode doctor check ${index} is invalid`)
+    }
+    return { name, severity, message, ...(fix ? { fix } : {}) }
+  })
+  const warnings = checks.filter((check) => check.severity === 'warning')
+  const errors = checks.filter((check) => check.severity === 'error')
+  return {
+    status: errors.length === 0
+      ? 'ready'
+      : errors.some((check) => check.name.toLowerCase() === 'model')
+        ? 'model_required'
+        : 'blocked',
+    warnings,
+    errors,
+  }
+}
+
+function formatChecks(checks) {
+  return checks.map((check) => {
+    const suffix = check.fix ? `；建议：${check.fix}` : ''
+    return `${check.name}: ${check.message}${suffix}`
+  }).join('\n')
+}
+
+function runBounded(command, args, timeoutSeconds) {
+  const timeoutMs = Math.max(1, Number.isFinite(timeoutSeconds) ? timeoutSeconds : 10) * 1000
+  return new Promise((resolve) => {
+    let stdout = ''
+    let stderr = ''
+    let total = 0
+    let timedOut = false
+    let outputLimited = false
+    let settled = false
+    let timer
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    })
+    let killTimer
+    const finish = (result) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      clearTimeout(killTimer)
+      resolve(result)
+    }
+    const signal = (name) => {
+      try {
+        child.kill(name)
+      } catch (error) {
+        if (error?.code === 'ESRCH') return
+        throw error
+      }
+    }
+    const terminate = () => {
+      signal('SIGTERM')
+      if (!killTimer) killTimer = setTimeout(() => {
+        signal('SIGKILL')
+        child.stdout.destroy()
+        child.stderr.destroy()
+        finish({ code: child.exitCode, signal: child.signalCode, stdout, stderr, timedOut, outputLimited })
+      }, 500)
+      killTimer.unref()
+    }
+    const append = (target, chunk) => {
+      const text = chunk.toString('utf8')
+      total += Buffer.byteLength(text)
+      if (total > MAX_OUTPUT_BYTES) {
+        if (!outputLimited) {
+          outputLimited = true
+          clearTimeout(timer)
+          terminate()
+        }
+        return target
+      }
+      return target + text
+    }
+    child.stdout.on('data', (chunk) => { stdout = append(stdout, chunk) })
+    child.stderr.on('data', (chunk) => { stderr = append(stderr, chunk) })
+    timer = setTimeout(() => {
+      timedOut = true
+      terminate()
+    }, timeoutMs)
+    child.once('error', (error) => {
+      finish({ spawnError: error, stdout, stderr, timedOut, outputLimited })
+    })
+    child.once('close', (code, signal) => {
+      finish({ code, signal, stdout, stderr, timedOut, outputLimited })
+    })
+  })
+}
+
+async function main() {
+  const [action, command, timeoutRaw] = process.argv.slice(2)
+  if (!['probe-acp', 'doctor'].includes(action) || !command) process.exit(64)
+  const result = await runBounded(command, action === 'probe-acp'
+    ? ['acp', 'serve', '--help']
+    : ['doctor', '--json'], Number(timeoutRaw || '10'))
+  if (result.timedOut) process.exit(EXIT.timeout)
+  if (result.outputLimited) process.exit(EXIT.execution)
+  if (result.spawnError) process.exit(result.spawnError.code === 'ENOENT' ? EXIT.missing : EXIT.execution)
+
+  if (action === 'probe-acp') {
+    process.exit(result.code === 0 && supportsTraeCodeAcpHelp(`${result.stdout}\n${result.stderr}`)
+      ? 0
+      : EXIT.unsupported)
+  }
+
+  if (![0, 1, 2].includes(result.code)) {
+    process.stderr.write('TraeCode doctor failed with an unsupported exit code')
+    process.exit(EXIT.execution)
+  }
+  let parsed
+  try {
+    parsed = parseTraeCodeDoctor(result.stdout, process.env.HOME || '')
+  } catch (error) {
+    process.stderr.write(error.message)
+    process.exit(EXIT.invalid)
+  }
+  if (parsed.status === 'ready') {
+    if (parsed.warnings.length) process.stdout.write(formatChecks(parsed.warnings))
+    process.exit(0)
+  }
+  process.stdout.write(formatChecks(parsed.errors))
+  process.exit(parsed.status === 'model_required' ? EXIT.model : EXIT.blocked)
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((error) => {
+    process.stderr.write(cleanText(error?.message || error, process.env.HOME) || 'TraeCode readiness check failed')
+    process.exit(EXIT.execution)
+  })
+}