@11agents/cli 0.1.1

package/src/commands/push.js

@@ -0,0 +1,56 @@
+import { readFile } from 'node:fs/promises'
+import { flag, listFlag, parseMetricFlags } from '../args.js'
+import { requestJson } from '../client.js'
+import { buildTelemetryBatch, validateTelemetryBatch } from '../schema.js'
+
+function defaults(flags) {
+  return {
+    workspace: flag(flags, 'workspace', process.env.GTM_SWARM_WORKSPACE || ''),
+    agent_key: flag(flags, 'agent', process.env.GTM_SWARM_AGENT || ''),
+    node_id: flag(flags, 'node', process.env.GTM_SWARM_NODE || 'local'),
+  }
+}
+
+async function sendBatch(batch) {
+  const validation = validateTelemetryBatch(batch)
+  if (!validation.ok) throw new Error(validation.error)
+  return requestJson('/api/swarm/ingest', { method: 'POST', body: batch })
+}
+
+export async function pushBatch(file) {
+  const body = JSON.parse(await readFile(file, 'utf-8'))
+  const result = await sendBatch(body)
+  console.log(JSON.stringify(result, null, 2))
+}
+
+export async function pushArtifact(flags) {
+  const base = defaults(flags)
+  const artifact = {
+    platform: flag(flags, 'platform', 'x'),
+    artifact_type: flag(flags, 'type'),
+    external_id: flag(flags, 'external-id'),
+    url: flag(flags, 'url') || null,
+    title: flag(flags, 'title') || null,
+    body: flag(flags, 'body') || null,
+    created_at: flag(flags, 'created-at', new Date().toISOString()),
+    payload: {},
+  }
+  const batch = buildTelemetryBatch({ ...base, artifacts: [artifact], observations: [] })
+  const result = await sendBatch(batch)
+  console.log(JSON.stringify(result, null, 2))
+}
+
+export async function pushObservation(flags) {
+  const base = defaults(flags)
+  const observation = {
+    platform: flag(flags, 'platform', 'x'),
+    artifact_type: flag(flags, 'type'),
+    external_id: flag(flags, 'external-id'),
+    observed_at: flag(flags, 'observed-at', new Date().toISOString()),
+    metrics: parseMetricFlags(listFlag(flags, 'metric')),
+    payload: {},
+  }
+  const batch = buildTelemetryBatch({ ...base, artifacts: [], observations: [observation] })
+  const result = await sendBatch(batch)
+  console.log(JSON.stringify(result, null, 2))
+}

package/src/commands/runtime.js

@@ -0,0 +1,353 @@
+import { spawn } from 'node:child_process'
+import { readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { fileURLToPath } from 'node:url'
+import { flag } from '../args.js'
+import { getControlConfig, requestJson } from '../client.js'
+import { buildRuntimeScan } from '../runtime-scan.js'
+
+const CLI_VERSION = JSON.parse(readFileSync(resolve(dirname(fileURLToPath(import.meta.url)), '../../package.json'), 'utf-8')).version
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+function runProcess(command, args, { input = '', cwd = process.cwd(), env = process.env } = {}) {
+  return new Promise(resolve => {
+    const child = spawn(command, args, { cwd, env, stdio: ['pipe', 'pipe', 'pipe'] })
+    let stdout = ''
+    let stderr = ''
+    child.stdout.on('data', chunk => { stdout += chunk })
+    child.stderr.on('data', chunk => { stderr += chunk })
+    child.on('error', error => {
+      resolve({ code: 127, stdout, stderr: error.message })
+    })
+    child.on('close', code => {
+      resolve({ code: code ?? 1, stdout, stderr })
+    })
+    child.stdin.end(input)
+  })
+}
+
+function configFromFlags(flags) {
+  return getControlConfig({
+    server: flag(flags, 'server'),
+    token: flag(flags, 'token'),
+  })
+}
+
+function machineOverride(flags) {
+  return flag(flags, 'machine')
+}
+
+function scanEnvWithOverrides(flags) {
+  const machine = machineOverride(flags)
+  if (!machine) return process.env
+  return {
+    ...process.env,
+    ELEVENAGENTS_MACHINE: machine,
+  }
+}
+
+function runtimeDeps(overrides = {}) {
+  return {
+    buildRuntimeScan: overrides.buildRuntimeScan || buildRuntimeScan,
+    importHandler: overrides.importHandler || (async handlerPath => import(pathToFileURL(resolve(handlerPath)).href)),
+    log: overrides.log || (value => console.log(value)),
+    runCodex: overrides.runCodex || runCodex,
+    runProcess: overrides.runProcess || runProcess,
+    requestJson: overrides.requestJson || requestJson,
+    sleep: overrides.sleep || sleep,
+  }
+}
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function retryDelayMs(failures) {
+  const initialMs = 1000
+  const maxMs = 15 * 60 * 1000
+  return Math.min(maxMs, initialMs * (2 ** Math.max(0, failures - 1)))
+}
+
+function createRetryState() {
+  return { failures: 0 }
+}
+
+async function runWithDaemonRetry(label, operation, deps, retryState) {
+  while (true) {
+    try {
+      const result = await operation()
+      retryState.failures = 0
+      return result
+    } catch (error) {
+      retryState.failures += 1
+      const delay = retryDelayMs(retryState.failures)
+      deps.log(JSON.stringify({
+        retrying: label,
+        error: errorMessage(error),
+        consecutive_failures: retryState.failures,
+        next_retry_ms: delay,
+      }, null, 2))
+      await deps.sleep(delay)
+    }
+  }
+}
+
+export async function scanRuntime(flags = {}) {
+  const scan = await buildRuntimeScan({ env: scanEnvWithOverrides(flags), cliVersion: CLI_VERSION })
+  console.log(JSON.stringify(scan, null, 2))
+  return scan
+}
+
+export async function registerRuntime(flags = {}, deps = {}) {
+  const { buildRuntimeScan: scanBuilder, log, requestJson: request } = runtimeDeps(deps)
+  const config = configFromFlags(flags)
+  if (!config.token) throw new Error('GTM_WRITES_TOKEN or --token is required')
+
+  const scan = await scanBuilder({ env: scanEnvWithOverrides(flags), cliVersion: CLI_VERSION })
+  if (!scan.runtimes.length) throw new Error('no local AI runtimes detected on PATH')
+
+  const result = await request('/api/runtime/machines/register', {
+    method: 'POST',
+    body: scan,
+    config,
+  })
+  log(JSON.stringify(result, null, 2))
+  return result
+}
+
+export async function heartbeatRuntime(flags = {}, deps = {}) {
+  const { buildRuntimeScan: scanBuilder, log, requestJson: request } = runtimeDeps(deps)
+  const config = configFromFlags(flags)
+  if (!config.token) throw new Error('GTM_WRITES_TOKEN or --token is required')
+
+  const scan = await scanBuilder({ env: scanEnvWithOverrides(flags), cliVersion: CLI_VERSION })
+  const result = await request('/api/runtime/machines/heartbeat', {
+    method: 'POST',
+    body: {
+      machine_key: scan.machine.machine_key,
+      runtime_providers: scan.runtimes.map(runtime => runtime.provider),
+      health: {
+        heartbeat_at: new Date().toISOString(),
+      },
+    },
+    config,
+  })
+  log(JSON.stringify(result, null, 2))
+  return result
+}
+
+function normalizeTaskCompletion(task, completion) {
+  const result = completion && typeof completion === 'object' ? completion : {}
+  return {
+    task_id: task.id,
+    runtime_id: task.runtime_id,
+    machine_key: task.runtime?.machine_key || '',
+    comment: String(result.comment || result.summary || ''),
+    memory_delta: String(result.memory_delta || result.memoryDelta || ''),
+    status: result.status ? String(result.status) : null,
+  }
+}
+
+async function loadTaskHandler(handlerPath, deps) {
+  if (!handlerPath) return null
+  const handlerModule = await deps.importHandler(handlerPath)
+  if (typeof handlerModule.handleRuntimeTask !== 'function') {
+    throw new Error('handler must export async function handleRuntimeTask(task)')
+  }
+  return handlerModule
+}
+
+function compactJson(value) {
+  return JSON.stringify(value ?? null, null, 2)
+}
+
+function buildCodexPrompt(task) {
+  return [
+    'You are executing an 11agents task as the assigned agent.',
+    '',
+    'Task context:',
+    compactJson({
+      queue_event: task.queue_event,
+      workspace: task.workspace,
+      issue: task.issue,
+      trigger_summary: task.trigger_summary,
+      thread_memory: task.thread_memory,
+    }),
+    '',
+    'Assigned agent context:',
+    compactJson({
+      id: task.agent?.id,
+      name: task.agent?.name,
+      instructions: task.agent?.instructions,
+      goal: task.agent?.goal,
+      memory: task.agent?.memory,
+      permissions: task.agent?.permissions,
+      triggers: task.agent?.triggers,
+      skills: task.agent?.skills,
+    }),
+    '',
+    'Thread comments:',
+    compactJson(task.comments || []),
+    '',
+    'Work in this repository and make the needed changes. When finished, respond with a concise summary for the task thread.',
+  ].join('\n')
+}
+
+async function runCodex({ task, prompt, flags = {}, deps }) {
+  const codexBin = flag(flags, 'codex-bin', 'codex')
+  const workdir = flag(flags, 'codex-workdir', process.cwd())
+  const args = [
+    '--ask-for-approval',
+    'never',
+    'exec',
+    '--sandbox',
+    flag(flags, 'codex-sandbox', 'workspace-write'),
+    '-C',
+    workdir,
+    '-',
+  ]
+  const model = flag(flags, 'codex-model')
+  const profile = flag(flags, 'codex-profile')
+  const execIndex = args.indexOf('exec')
+  if (model) args.splice(execIndex + 1, 0, '--model', model)
+  if (profile) args.splice(execIndex + 1, 0, '--profile', profile)
+
+  const result = await deps.runProcess(codexBin, args, { input: prompt, cwd: workdir })
+  const output = String(result.stdout || '').trim()
+  const error = String(result.stderr || '').trim()
+  if (result.code !== 0) {
+    return {
+      comment: error || output || `codex exited with status ${result.code}`,
+      status: 'failed',
+    }
+  }
+  return {
+    comment: output || `Codex completed task ${task.id}.`,
+    memory_delta: `Codex completed task ${task.id}.`,
+    status: 'in_review',
+  }
+}
+
+function defaultTaskHandler(flags, deps) {
+  return {
+    async handleRuntimeTask(task) {
+      const provider = task.runtime?.provider || ''
+      if (provider !== 'codex') {
+        return {
+          comment: `unsupported runtime provider: ${provider || 'unknown'}`,
+          status: 'failed',
+        }
+      }
+      const prompt = buildCodexPrompt(task)
+      return deps.runCodex({ task, prompt, flags, deps })
+    },
+  }
+}
+
+async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule, retryState = createRetryState()) {
+  if (!handlerModule) return 0
+  const config = configFromFlags(flags)
+  const machineKey = registration?.machine?.machine_key || machineOverride(flags) || ''
+  let handled = 0
+
+  for (const runtime of registration?.runtimes || []) {
+    if (!runtime?.id) continue
+    const claim = await runWithDaemonRetry('claim runtime task', () => (
+      deps.requestJson('/api/runtime/tasks/claim', {
+        method: 'POST',
+        body: {
+          runtime_id: runtime.id,
+          machine_key: machineKey,
+        },
+        config,
+      })
+    ), deps, retryState)
+    const task = claim?.task
+    if (!task) continue
+
+    const runtimeTask = {
+      ...task,
+      runtime_id: task.runtime_id || runtime.id,
+      runtime: {
+        provider: runtime.provider,
+        model: runtime.model || '',
+        ...(task.runtime || {}),
+        id: task.runtime?.id || runtime.id,
+        machine_key: task.runtime?.machine_key || machineKey,
+      },
+    }
+
+    deps.log(JSON.stringify({ claimed: runtimeTask.id, runtime_id: runtime.id }, null, 2))
+    let completion
+    try {
+      completion = await handlerModule.handleRuntimeTask(runtimeTask)
+    } catch (error) {
+      completion = {
+        comment: error instanceof Error ? error.message : String(error),
+        status: 'failed',
+      }
+    }
+
+    const body = normalizeTaskCompletion(runtimeTask, completion)
+    const result = await runWithDaemonRetry('complete runtime task', () => (
+      deps.requestJson('/api/runtime/tasks/complete', {
+        method: 'POST',
+        body,
+        config,
+      })
+    ), deps, retryState)
+    deps.log(JSON.stringify(result, null, 2))
+    handled += 1
+  }
+
+  return handled
+}
+
+export async function startRuntimeDaemon(flags = {}, deps = {}) {
+  const resolvedDeps = runtimeDeps(deps)
+  const heartbeatIntervalMs = Number(flag(flags, 'heartbeat-interval', '15')) * 1000
+  const scanIntervalMs = Number(flag(flags, 'scan-interval', '60')) * 1000
+  const taskIntervalMs = Number(flag(flags, 'task-interval', flag(flags, 'heartbeat-interval', '15'))) * 1000
+  const once = Boolean(flags.once)
+  const handlerPath = flag(flags, 'handler')
+
+  if (!Number.isFinite(heartbeatIntervalMs) || heartbeatIntervalMs <= 0) {
+    throw new Error('--heartbeat-interval must be a positive number of seconds')
+  }
+  if (!Number.isFinite(scanIntervalMs) || scanIntervalMs <= 0) {
+    throw new Error('--scan-interval must be a positive number of seconds')
+  }
+  if (!Number.isFinite(taskIntervalMs) || taskIntervalMs <= 0) {
+    throw new Error('--task-interval must be a positive number of seconds')
+  }
+
+  const handlerModule = await loadTaskHandler(handlerPath, resolvedDeps) || defaultTaskHandler(flags, resolvedDeps)
+  const retryState = createRetryState()
+  let registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
+  await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState)
+  if (once) return
+
+  let lastScan = Date.now()
+  let lastHeartbeat = Date.now()
+  let lastTaskPoll = Date.now()
+  while (true) {
+    await resolvedDeps.sleep(Math.min(heartbeatIntervalMs, taskIntervalMs))
+    const now = Date.now()
+    if (now - lastScan >= scanIntervalMs) {
+      registration = await runWithDaemonRetry('register runtime', () => registerRuntime(flags, resolvedDeps), resolvedDeps, retryState)
+      lastScan = now
+      lastHeartbeat = now
+    } else if (now - lastHeartbeat >= heartbeatIntervalMs) {
+      await runWithDaemonRetry('heartbeat runtime', () => heartbeatRuntime(flags, resolvedDeps), resolvedDeps, retryState)
+      lastHeartbeat = now
+    }
+    if (now - lastTaskPoll >= taskIntervalMs) {
+      await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState)
+      lastTaskPoll = now
+    }
+  }
+}

package/src/daemon-process.js

@@ -0,0 +1,92 @@
+import { constants } from 'node:fs'
+import { mkdir, open, readFile, rm, writeFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { spawn } from 'node:child_process'
+
+export function backgroundPaths(homeDir = homedir()) {
+  const dir = join(homeDir, '.11agents')
+  return {
+    dir,
+    pidPath: join(dir, 'daemon.pid'),
+    logPath: join(dir, 'daemon.log'),
+  }
+}
+
+function withoutBackgroundFlag(argv) {
+  return argv.filter(arg => arg !== '--background')
+}
+
+function parsePid(raw) {
+  const pid = Number.parseInt(String(raw).trim(), 10)
+  return Number.isFinite(pid) && pid > 0 ? pid : null
+}
+
+async function readPid(pidPath) {
+  try {
+    return parsePid(await readFile(pidPath, 'utf-8'))
+  } catch (error) {
+    if (error?.code === 'ENOENT') return null
+    throw error
+  }
+}
+
+function isRunning(pid, killFn = process.kill) {
+  if (!pid) return false
+  try {
+    killFn(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function startBackgroundDaemon({
+  argv,
+  homeDir = homedir(),
+  nodePath = process.execPath,
+  scriptPath,
+  spawnFn = spawn,
+} = {}) {
+  const paths = backgroundPaths(homeDir)
+  await mkdir(paths.dir, { recursive: true })
+  const existingPid = await readPid(paths.pidPath)
+  if (isRunning(existingPid)) {
+    return { alreadyRunning: true, pid: existingPid, logPath: paths.logPath }
+  }
+
+  const log = await open(paths.logPath, constants.O_CREAT | constants.O_APPEND | constants.O_WRONLY, 0o600)
+  try {
+    const child = spawnFn(nodePath, [scriptPath, ...withoutBackgroundFlag(argv)], {
+      detached: true,
+      stdio: ['ignore', log.fd, log.fd],
+      env: {
+        ...process.env,
+        ELEVENAGENTS_DAEMON_BACKGROUND_CHILD: '1',
+      },
+    })
+    if (!child?.pid) throw new Error('failed to start daemon')
+    await writeFile(paths.pidPath, String(child.pid))
+    child.unref?.()
+    return { pid: child.pid, logPath: paths.logPath }
+  } finally {
+    await log.close()
+  }
+}
+
+export async function statusBackgroundDaemon({ homeDir = homedir(), killFn = process.kill } = {}) {
+  const paths = backgroundPaths(homeDir)
+  const pid = await readPid(paths.pidPath)
+  if (!pid) return { running: false, stale: false, pid: null, logPath: paths.logPath }
+  const running = isRunning(pid, killFn)
+  return { running, stale: !running, pid, logPath: paths.logPath }
+}
+
+export async function stopBackgroundDaemon({ homeDir = homedir(), killFn = process.kill } = {}) {
+  const paths = backgroundPaths(homeDir)
+  const pid = await readPid(paths.pidPath)
+  if (!pid) return { stopped: false, pid: null }
+  if (isRunning(pid, killFn)) killFn(pid, 'SIGTERM')
+  await rm(paths.pidPath, { force: true })
+  return { stopped: true, pid }
+}

package/src/info.js

@@ -0,0 +1,62 @@
+import { readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const PACKAGE_PATH = resolve(dirname(fileURLToPath(import.meta.url)), '../package.json')
+export const CLI_VERSION = JSON.parse(readFileSync(PACKAGE_PATH, 'utf-8')).version
+
+export function compareVersions(current, latest) {
+  const left = String(current).split(/[.-]/).map(part => Number.parseInt(part, 10) || 0)
+  const right = String(latest).split(/[.-]/).map(part => Number.parseInt(part, 10) || 0)
+  const length = Math.max(left.length, right.length)
+  for (let i = 0; i < length; i += 1) {
+    if ((left[i] || 0) < (right[i] || 0)) return -1
+    if ((left[i] || 0) > (right[i] || 0)) return 1
+  }
+  return 0
+}
+
+export async function fetchLatestVersion({ fetchFn = globalThis.fetch, timeoutMs = 1500 } = {}) {
+  if (typeof fetchFn !== 'function') return null
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeoutMs)
+  try {
+    const response = await fetchFn('https://registry.npmjs.org/@11agents%2fcli/latest', {
+      signal: controller.signal,
+      headers: { accept: 'application/json' },
+    })
+    if (!response.ok) return null
+    const data = await response.json()
+    return data?.version ? String(data.version) : null
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+export async function buildStartupInfo({
+  currentVersion = CLI_VERSION,
+  server,
+  fetchLatestVersion: latestVersionFetcher = fetchLatestVersion,
+} = {}) {
+  const lines = [
+    `11agents CLI ${currentVersion}`,
+    `server: ${server}`,
+  ]
+
+  try {
+    const latest = await latestVersionFetcher()
+    if (latest && compareVersions(currentVersion, latest) < 0) {
+      lines.push(`New version available: ${currentVersion} -> ${latest}. Upgrade: npm install -g @11agents/cli@latest`)
+    }
+  } catch {
+    // Startup info must never block CLI work.
+  }
+
+  return lines
+}
+
+export async function printStartupInfo(options = {}) {
+  if (options.quiet) return
+  const lines = await buildStartupInfo(options)
+  for (const line of lines) console.error(line)
+}

package/src/runtime-scan.js

@@ -0,0 +1,114 @@
+import os from 'node:os'
+import path from 'node:path'
+import { access } from 'node:fs/promises'
+import { constants } from 'node:fs'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+
+const execFileAsync = promisify(execFile)
+
+export const RUNTIME_EXECUTABLES = [
+  { provider: 'codex', executable: 'codex' },
+  { provider: 'claude', executable: 'claude' },
+  { provider: 'gemini', executable: 'gemini' },
+  { provider: 'cursor', executable: 'cursor-agent' },
+  { provider: 'copilot', executable: 'copilot' },
+  { provider: 'opencode', executable: 'opencode' },
+  { provider: 'openclaw', executable: 'openclaw' },
+  { provider: 'hermes', executable: 'hermes' },
+  { provider: 'pi', executable: 'pi' },
+  { provider: 'kimi', executable: 'kimi' },
+  { provider: 'kiro', executable: 'kiro-cli' },
+]
+
+function machineKeyFromEnv(env, hostname) {
+  return env.ELEVENAGENTS_MACHINE || env['11AGENTS_MACHINE'] || env.GTM_SWARM_NODE || hostname
+}
+
+export async function lookupExecutable(name, env = process.env) {
+  const pathValue = env.PATH || ''
+  const extensions = process.platform === 'win32'
+    ? (env.PATHEXT || '.EXE;.CMD;.BAT;.COM').split(';')
+    : ['']
+  for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
+    for (const ext of extensions) {
+      const candidate = path.join(dir, `${name}${ext}`)
+      try {
+        await access(candidate, constants.X_OK)
+        return candidate
+      } catch {}
+    }
+  }
+  return ''
+}
+
+export async function readRuntimeVersion(_provider, executablePath) {
+  const attempts = [
+    ['--version'],
+    ['version'],
+    ['-v'],
+  ]
+  let lastError = null
+  for (const args of attempts) {
+    try {
+      const { stdout, stderr } = await execFileAsync(executablePath, args, { timeout: 5000 })
+      const text = `${stdout || ''}${stderr || ''}`.trim()
+      if (text) return text.split('\n')[0]
+    } catch (error) {
+      lastError = error
+    }
+  }
+  throw lastError || new Error('version unavailable')
+}
+
+export async function buildRuntimeScan({
+  env = process.env,
+  hostname = os.hostname,
+  platform = process.platform,
+  arch = process.arch,
+  cliVersion = 'dev',
+  lookupExecutable: lookup = lookupExecutable,
+  readVersion = readRuntimeVersion,
+} = {}) {
+  const host = hostname()
+  const runtimes = []
+
+  for (const item of RUNTIME_EXECUTABLES) {
+    const executablePath = await lookup(item.executable, env)
+    if (!executablePath) continue
+
+    let version = null
+    const health = {}
+    try {
+      version = await readVersion(item.provider, executablePath)
+    } catch (error) {
+      health.version_error = error instanceof Error ? error.message : String(error)
+    }
+
+    runtimes.push({
+      provider: item.provider,
+      executable: item.executable,
+      executable_path: executablePath,
+      version,
+      model: env[`ELEVENAGENTS_${item.provider.toUpperCase()}_MODEL`] || '',
+      status: 'online',
+      capabilities: ['code', 'terminal'],
+      health,
+    })
+  }
+
+  return {
+    machine: {
+      machine_key: machineKeyFromEnv(env, host),
+      hostname: host,
+      platform,
+      arch,
+      cli_version: cliVersion,
+      capabilities: ['local_runtime'],
+    },
+    runtimes,
+    health: {
+      scan_at: new Date().toISOString(),
+    },
+  }
+}