@11agents/cli 0.1.21 → 0.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@11agents/cli",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "11agents local runtime and telemetry CLI",
   "type": "module",
   "bin": {

package/src/commands/runtime.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process'
 import { createHash } from 'node:crypto'
 import { appendFileSync, readFileSync } from 'node:fs'
-import { appendFile, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises'
+import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises'
 import os from 'node:os'
 import { dirname, resolve } from 'node:path'
 import path from 'node:path'
@@ -312,6 +312,63 @@ function normalizeTaskCompletion(task, completion) {
   return body
 }
 
+function runtimeAssetContentType(filePath) {
+  const ext = path.extname(filePath).toLowerCase()
+  if (ext === '.html') return 'text/html; charset=utf-8'
+  if (ext === '.png') return 'image/png'
+  if (ext === '.webp') return 'image/webp'
+  if (ext === '.jpg' || ext === '.jpeg') return 'image/jpeg'
+  if (ext === '.mp4') return 'video/mp4'
+  if (ext === '.md') return 'text/markdown; charset=utf-8'
+  if (ext === '.json') return 'application/json; charset=utf-8'
+  return 'application/octet-stream'
+}
+
+function isInsideDir(filePath, dir) {
+  if (!filePath || !dir) return false
+  const relative = path.relative(resolve(dir), resolve(filePath))
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
+}
+
+function localMarkdownLinkTargets(text) {
+  const targets = new Set()
+  const linkPattern = /!?\[[^\]]*\]\(([^)\s]+)(?:\s+["'][^"']*["'])?\)/g
+  for (const match of String(text || '').matchAll(linkPattern)) {
+    const raw = String(match[1] || '').trim()
+    if (!raw || /^https?:\/\//i.test(raw) || raw.startsWith('/api/')) continue
+    let decoded = raw
+    try { decoded = decodeURI(raw) } catch {}
+    if (path.isAbsolute(decoded)) targets.add(decoded)
+  }
+  return [...targets]
+}
+
+async function attachRuntimeAssetsToCompletion(body, task, executionContext) {
+  if (!executionContext || !body?.comment) return body
+  const allowedDirs = [executionContext.agent_results_dir, executionContext.run_dir].filter(Boolean)
+  const projectSlug = projectSlugForTask(task)
+  const assets = []
+  let nextComment = String(body.comment || '')
+  for (const target of localMarkdownLinkTargets(nextComment)) {
+    if (!allowedDirs.some(dir => isInsideDir(target, dir))) continue
+    const fileStat = await stat(target).catch(() => null)
+    if (!fileStat?.isFile()) continue
+    const bytes = await readFile(target)
+    const assetHash = createHash('sha256').update(target).digest('hex')
+    const url = `/api/projects/${encodeURIComponent(projectSlug)}/assets/${assetHash}`
+    nextComment = nextComment.split(target).join(url)
+    assets.push({
+      original_path: target,
+      asset_hash: assetHash,
+      filename: path.basename(target),
+      content_type: runtimeAssetContentType(target),
+      size_bytes: fileStat.size,
+      body_base64: bytes.toString('base64'),
+    })
+  }
+  return assets.length ? { ...body, comment: nextComment, assets } : body
+}
+
 function failedClaimCompletionBody(claim, comment) {
   return {
     task_id: String(claim?.task_id || ''),
@@ -992,6 +1049,9 @@ function buildCodexPrompt(task) {
     '4. tmp_dir: Scratch/working files only. This directory is deleted by the CLI after the task finishes — do NOT put deliverables here.',
     '5. workdir: Treat as read-only project context except for the four agent directories and knowledge_base above.',
     '',
+    'MCP tool guidance:',
+    '- If the task needs image generation, use the hosted 11agents MCP `image_generate` tool when available.',
+    '',
     'Task context:',
     compactJson({
       queue_event: task.queue_event,
@@ -1382,7 +1442,11 @@ async function runOneRuntimeTaskSlot(runtime, config, machineKey, registration,
     }
   }
 
-  const body = normalizeTaskCompletion(runtimeTask, completion)
+  const body = await attachRuntimeAssetsToCompletion(
+    normalizeTaskCompletion(runtimeTask, completion),
+    runtimeTask,
+    executionContext
+  )
   const result = await runWithDaemonRetry('complete runtime task', () => (
     deps.requestJson('/api/runtime/tasks/complete', {
       method: 'POST',
@@ -1409,6 +1473,15 @@ async function claimAndRunRuntimeTasks(registration, flags, deps, handlerModule,
   return results.filter(r => r.status === 'fulfilled' && r.value === true).length
 }
 
+async function drainRuntimeTasks(registration, flags, deps, handlerModule, retryState = createRetryState(), heartbeatIntervalMs = 15000, maxConcurrent = 1) {
+  let completed = 0
+  while (true) {
+    const claimed = await claimAndRunRuntimeTasks(registration, flags, deps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
+    completed += claimed
+    if (claimed === 0) return completed
+  }
+}
+
 export async function startRuntimeDaemon(flags = {}, deps = {}) {
   const resolvedDeps = runtimeDeps(deps)
   const heartbeatIntervalMs = Number(flag(flags, 'heartbeat-interval', '15')) * 1000
@@ -1443,8 +1516,11 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
       'Runtime task failed locally: daemon restarted with a persisted claimed task that had not completed.'
     ), resolvedDeps, retryState)
     await syncRuntimeProjectMetadataBestEffort(flags, resolvedDeps)
-    await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
-    if (once) return
+    if (once) {
+      await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
+      return
+    }
+    await drainRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
 
     let lastScan = Date.now()
     let lastHeartbeat = Date.now()
@@ -1462,7 +1538,7 @@ export async function startRuntimeDaemon(flags = {}, deps = {}) {
         lastHeartbeat = now
       }
       if (now - lastTaskPoll >= taskIntervalMs) {
-        await claimAndRunRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
+        await drainRuntimeTasks(registration, flags, resolvedDeps, handlerModule, retryState, heartbeatIntervalMs, maxConcurrent)
         lastTaskPoll = now
       }
       if (now - lastProjectRefresh >= projectRefreshIntervalMs) {