threadwire 0.1.5 → 0.1.8

package/src/telegram-ingress/core.js

@@ -1,30 +1,35 @@
 // @ts-check
 
-import {createHash, timingSafeEqual} from "node:crypto"
+import {createHash, randomUUID, timingSafeEqual} from "node:crypto"
+import {evidenceTelegramDestination} from "../evidence-store.js"
 import {NoticeQueue} from "../notice-queue.js"
 import {createFetchTransport} from "../notifiers/fetch-transport.js"
 import {createTelegramSender} from "../notifiers/telegram.js"
 import {createProvider} from "../providers/index.js"
 import {Relay} from "../relay.js"
 import {runWorker} from "../run-worker.js"
+import {WorkerControl} from "../worker-control.js"
 import {resolveWorkspaceProfile} from "../workspace-profile.js"
-import {buildProviderEnvironment} from "./config.js"
-import {parseCodeCommand} from "./command.js"
+import {buildProviderEnvironment, collectEvidenceRedactions} from "./config.js"
+import {parseCodeCommand, parseEvidenceCommand} from "./command.js"
 
 /**
  * @typedef {{platform: "telegram", chatId: string, threadId: number | null}} TelegramTarget
- * @typedef {{provider: "codex" | "claude" | "opencode", prompt: string, target: TelegramTarget}} AcceptedJob
+ * @typedef {{provider: "codex" | "claude" | "opencode", prompt: string, target: TelegramTarget, senderId: string} | {type: "evidence", request: unknown, target: TelegramTarget, senderId: string}} AcceptedJob
  * @typedef {{
  *   createProvider?: typeof createProvider,
  *   createFetchTransport?: typeof createFetchTransport,
  *   createTelegramSender?: typeof createTelegramSender,
  *   runWorker?: typeof runWorker,
+ *   WorkerControl?: typeof WorkerControl,
  *   NoticeQueue?: typeof NoticeQueue,
  *   Relay?: typeof Relay,
  *   processNumber?: number,
  *   providerEnvironment?: NodeJS.ProcessEnv,
  *   workspaceProfileOperations?: import("../workspace-profile.js").WorkspaceProfileOperations,
  *   activity?: Pick<import("../activity-log.js").ActivityLog, "recordWorkspace" | "recordStarted" | "recordSession" | "close">,
+ *   evidenceStore?: import("../evidence-store.js").EvidenceStore,
+ *   isolatedRuntimeClient?: Pick<import("../isolated-runtime-client.js").IsolatedRuntimeClient, "preflight" | "run">,
  *   onWorkerFailure?: (message: string) => void,
  *   onWorkerSettled?: () => void
  * }} IngressDependencies
@@ -55,11 +60,12 @@ export function interpretUpdate(update, config) {
   if (!isRecord(update)) return null
   const message = update.message
   if (!isRecord(message)) return null
+  if ([
+    "forward_origin", "forward_from", "forward_from_chat", "forward_signature",
+    "forward_sender_name", "is_automatic_forward"
+  ].some((field) => Object.prototype.hasOwnProperty.call(message, field))) return null
   if (typeof message.text !== "string") return null
 
-  const command = parseCodeCommand(message.text)
-  if (!command) return null
-
   const chatId = telegramIdString(isRecord(message.chat) ? message.chat.id : undefined)
   if (chatId === null || !config.allowedChatIds.has(chatId)) return null
 
@@ -69,7 +75,11 @@ export function interpretUpdate(update, config) {
   const target = deriveTarget(chatId, message.message_thread_id)
   if (target === null) return null
 
-  return {provider: command.provider, prompt: command.prompt, target}
+  const command = parseCodeCommand(message.text)
+  if (command) return {provider: command.provider, prompt: command.prompt, target, senderId}
+  const evidence = parseEvidenceCommand(message.text)
+  if (evidence) return {type: "evidence", request: evidence, target, senderId}
+  return null
 }
 
 /**
@@ -83,10 +93,12 @@ export function interpretUpdate(update, config) {
  * @returns {Promise<void>}
  */
 export async function dispatchWorker(job, config, dependencies = {}) {
+  if ("type" in job) throw new Error("Worker dispatch requires a worker job")
   const createProviderImpl = dependencies.createProvider ?? createProvider
   const createFetchTransportImpl = dependencies.createFetchTransport ?? createFetchTransport
   const createTelegramSenderImpl = dependencies.createTelegramSender ?? createTelegramSender
   const runWorkerImpl = dependencies.runWorker ?? runWorker
+  const WorkerControlImpl = dependencies.WorkerControl ?? WorkerControl
   const NoticeQueueImpl = dependencies.NoticeQueue ?? NoticeQueue
   const RelayImpl = dependencies.Relay ?? Relay
   const processNumber = dependencies.processNumber ?? process.pid
@@ -106,111 +118,211 @@ export async function dispatchWorker(job, config, dependencies = {}) {
   )
   const transport = createFetchTransportImpl(config.botToken, undefined, config.telegramRequestTimeoutMs)
   const sender = createTelegramSenderImpl(job.target, transport)
-  const queue = new NoticeQueueImpl({sender})
-  const relay = new RelayImpl({queue, processNumber, toolMessages: config.toolMessages ?? false})
-
-  /** @type {{resolve: () => void, reject: (error: Error) => void, settled: boolean}} */
-  const spawnGate = {
-    settled: false,
-    resolve() {},
-    reject() {}
-  }
-  const spawned = new Promise((resolve, reject) => {
-    spawnGate.resolve = () => {
-      if (spawnGate.settled) return
-      spawnGate.settled = true
-      resolve(undefined)
+  const control = new WorkerControlImpl({
+    sender,
+    processNumber,
+    toolMessages: config.toolMessages ?? false,
+    NoticeQueueClass: NoticeQueueImpl,
+    RelayClass: RelayImpl
+  })
+  const evidenceOwner = dependencies.evidenceStore?.createOwnerScope({
+    destinationId: evidenceTelegramDestination(job.target, job.senderId),
+    runId: randomUUID()
+  })
+  const evidence = evidenceOwner === undefined ? undefined : await dependencies.evidenceStore?.createArtifact(evidenceOwner, {
+    contentType: "text/plain; charset=utf-8",
+    redactions: await collectEvidenceRedactions(dependencies.providerEnvironment ?? {})
+  })
+  let evidenceTransferred = false
+  try {
+    await evidence?.append("prompt", `prompt\n${job.prompt}\nprovider-stream\n`)
+
+    if (job.provider === "codex" && dependencies.isolatedRuntimeClient !== undefined) {
+      evidenceTransferred = true
+      try {
+        const preflight = await dependencies.isolatedRuntimeClient.preflight({
+          provider: "codex",
+          profile: workspace.profile,
+          repositoryRoot: workspace.repositoryRoot,
+          cwd: workspace.cwd,
+          providerArguments: []
+        })
+        const exitCode = await dependencies.isolatedRuntimeClient.run({
+          preflightId: preflight.preflightId,
+          prompt: job.prompt,
+          providerArguments: [],
+          ...(preflight.deadline === undefined ? {} : {deadline: preflight.deadline}),
+          onEvent: async (event) => control.accept(event),
+          onRecord: async (record) => {
+            const id = provider.sessionId(record)
+            if (id !== undefined) dependencies.activity?.recordSession(provider.name, id)
+          },
+          onStdoutChunk: (chunk) => evidence?.append("provider-stdout", chunk),
+          onStderrChunk: (chunk) => evidence?.append("provider-stderr", chunk)
+        })
+        if (exitCode !== 0) throw new Error(`Isolated Codex worker exited with status ${exitCode}`)
+        await control.close()
+        if (evidence !== undefined) {
+          await evidence.finalize()
+          await sender.send(`Evidence: ${evidence.handle}`)
+        }
+        return
+      } catch (error) {
+        await control.close().catch(() => {})
+        await evidence?.abort()
+        throw error
+      } finally {
+        dependencies.onWorkerSettled?.()
+      }
     }
-    spawnGate.reject = (error) => {
-      if (spawnGate.settled) return
-      spawnGate.settled = true
-      reject(error)
+
+    /** @type {{resolve: () => void, reject: (error: Error) => void, settled: boolean}} */
+    const spawnGate = {
+      settled: false,
+      resolve() {},
+      reject() {}
     }
-  })
+    const spawned = new Promise((resolve, reject) => {
+      spawnGate.resolve = () => {
+        if (spawnGate.settled) return
+        spawnGate.settled = true
+        resolve(undefined)
+      }
+      spawnGate.reject = (error) => {
+        if (spawnGate.settled) return
+        spawnGate.settled = true
+        reject(error)
+      }
+    })
 
-  /** @param {unknown} error */
-  const reportBackgroundFailure = (error) => {
-    const failure = error instanceof Error ? error : new Error(safeFailureMessage(error))
-    try {
-      dependencies.onWorkerFailure?.(safeFailureMessage(failure))
-    } catch {
+    /** @param {unknown} error */
+    const reportBackgroundFailure = (error) => {
+      const failure = error instanceof Error ? error : new Error(safeFailureMessage(error))
+      try {
+        dependencies.onWorkerFailure?.(safeFailureMessage(failure))
+      } catch {
       /* Observer errors must not become unhandled rejections. */
+      }
     }
-  }
 
-  const notifySettled = () => {
-    try {
-      dependencies.onWorkerSettled?.()
-    } catch {
+    const notifySettled = () => {
+      try {
+        dependencies.onWorkerSettled?.()
+      } catch {
       /* Observer errors must not become unhandled rejections. */
+      }
     }
-  }
 
-  const running = runWorkerImpl({
-    executable: provider.executable,
-    arguments: provider.arguments,
-    cwd: workspace.cwd,
-    environment: providerEnvironment,
-    parse: provider.parse,
-    onEvent: (event) => relay.accept(event),
-    onSpawn: (pid) => {
-      if (pid !== undefined) dependencies.activity?.recordStarted(provider.name, pid)
-      spawnGate.resolve()
-    },
-    onRecord: (record) => {
-      const id = provider.sessionId(record)
-      if (id !== undefined) dependencies.activity?.recordSession(provider.name, id)
-    }
-  })
+    const running = runWorkerImpl({
+      executable: provider.executable,
+      arguments: provider.arguments,
+      cwd: workspace.cwd,
+      environment: providerEnvironment,
+      parse: provider.parse,
+      onEvent: async (event) => control.accept(event),
+      onSpawn: (pid) => {
+        if (pid !== undefined) dependencies.activity?.recordStarted(provider.name, pid)
+        spawnGate.resolve()
+      },
+      onRecord: async (record) => {
+        const id = provider.sessionId(record)
+        if (id !== undefined) dependencies.activity?.recordSession(provider.name, id)
+      },
+      onStdoutChunk: (chunk) => evidence?.append("provider-stdout", chunk),
+      onStderrChunk: (chunk) => evidence?.append("provider-stderr", chunk)
+    })
 
-  // Detached observer: never resolves the spawn gate from process exit — only
-  // from onSpawn. Pre-spawn failure rejects the gate; post-spawn failure is
-  // reported. Always notify settlement so concurrency slots are released.
-  void (async () => {
-    try {
+    // Detached observer: never resolves the spawn gate from process exit — only
+    // from onSpawn. Pre-spawn failure rejects the gate; post-spawn failure is
+    // reported. Always notify settlement so concurrency slots are released.
+    evidenceTransferred = true
+    void (async () => {
       try {
-        await running
-      } catch (error) {
-        const failure = error instanceof Error ? error : new Error(safeFailureMessage(error))
-        if (spawnGate.settled) {
-          reportBackgroundFailure(failure)
-        } else {
-          spawnGate.reject(failure)
-        }
         try {
-          await relay.close()
-        } catch {
+          await running
+        } catch (error) {
+          const failure = error instanceof Error ? error : new Error(safeFailureMessage(error))
+          if (spawnGate.settled) {
+            reportBackgroundFailure(failure)
+          } else {
+            spawnGate.reject(failure)
+          }
+          try {
+            await control.close()
+          } catch {
           /* Best-effort close after worker failure. */
+          }
+          return
         }
-        return
-      }
 
-      try {
-        await relay.close()
+        try {
+          await control.close()
+        } catch (error) {
+          if (spawnGate.settled) {
+            reportBackgroundFailure(error)
+          } else {
+            spawnGate.reject(error instanceof Error ? error : new Error(safeFailureMessage(error)))
+          }
+          return
+        }
+
+        if (!spawnGate.settled) {
+          spawnGate.reject(new Error("Worker exited before spawn was observed"))
+        }
       } catch (error) {
         if (spawnGate.settled) {
           reportBackgroundFailure(error)
         } else {
           spawnGate.reject(error instanceof Error ? error : new Error(safeFailureMessage(error)))
         }
-        return
+      } finally {
+        if (evidence !== undefined) {
+          try {
+            await evidence.finalize()
+            await sender.send(`Evidence: ${evidence.handle}`)
+          } catch (error) {
+            await evidence.abort()
+            reportBackgroundFailure(error)
+          }
+        }
+        notifySettled()
       }
+    })()
 
-      if (!spawnGate.settled) {
-        spawnGate.reject(new Error("Worker exited before spawn was observed"))
-      }
-    } catch (error) {
-      if (spawnGate.settled) {
-        reportBackgroundFailure(error)
-      } else {
-        spawnGate.reject(error instanceof Error ? error : new Error(safeFailureMessage(error)))
-      }
-    } finally {
-      notifySettled()
-    }
-  })()
+    await spawned
+  } finally {
+    if (!evidenceTransferred) await evidence?.abort()
+  }
+}
+
+/** @param {Extract<AcceptedJob, {type: "evidence"}>} job @param {{botToken: string, telegramRequestTimeoutMs?: number}} config @param {IngressDependencies} dependencies */
+export async function dispatchEvidenceRead(job, config, dependencies) {
+  if (!dependencies.evidenceStore) throw new Error("Evidence retrieval is unavailable")
+  const transport = (dependencies.createFetchTransport ?? createFetchTransport)(config.botToken, undefined, config.telegramRequestTimeoutMs)
+  const sender = (dependencies.createTelegramSender ?? createTelegramSender)(job.target, transport)
+  const result = await dependencies.evidenceStore.readTelegram({...job.target, senderId: job.senderId}, job.request)
+  const label = result.encoding === "base64"
+    ? `Evidence (${result.contentType}, base64, truncated):\n`
+    : `Evidence (${result.contentType}, redacted, truncated):\n`
+  const boundedData = telegramEvidenceText(result.data, Math.max(0, 3_000 - Buffer.byteLength(label)))
+  await sender.send({
+    text: result.encoding === "base64"
+      ? `Evidence (${result.contentType}, base64${boundedData.truncated ? ", truncated" : ""}):\n${boundedData.text}`
+      : `Evidence (${result.contentType}${result.redacted ? ", redacted" : ""}${result.truncated || boundedData.truncated ? ", truncated" : ""}):\n${boundedData.text}`
+  })
+}
 
-  await spawned
+/** @param {string} value @param {number} maxBytes */
+function telegramEvidenceText(value, maxBytes) {
+  let text = ""
+  let bytes = 0
+  for (const character of value) {
+    const width = Buffer.byteLength(character, "utf8")
+    if (bytes + width > maxBytes) return {text, truncated: true}
+    text += character
+    bytes += width
+  }
+  return {text, truncated: false}
 }
 
 /** @param {string} chatId @param {unknown} threadId @returns {TelegramTarget | null} */

package/src/telegram-ingress/http.js

@@ -1,7 +1,7 @@
 // @ts-check
 
 import {createConcurrencyLimiter} from "./concurrency.js"
-import {dispatchWorker, interpretUpdate, secretsEqual} from "./core.js"
+import {dispatchEvidenceRead, dispatchWorker, interpretUpdate, secretsEqual} from "./core.js"
 import {createUpdateGuard, parseUpdateId} from "./update-guard.js"
 import {WorkspaceProviderMismatchError} from "../workspace-profile.js"
 
@@ -112,6 +112,22 @@ async function handleRequest(request, response, config, dependencies) {
       return
     }
 
+    if ("type" in job) {
+      try {
+        await dispatchEvidenceRead(job, {
+          botToken: config.botToken,
+          telegramRequestTimeoutMs: config.telegramRequestTimeoutMs
+        }, dependencies)
+        dependencies.updateGuard.complete(updateId)
+        send(response, 200)
+      } catch (error) {
+        dependencies.updateGuard.release(updateId)
+        dependencies.onOperationalError?.(error instanceof Error ? error.message : "Evidence retrieval failed")
+        send(response, 500)
+      }
+      return
+    }
+
     if (!dependencies.concurrency.tryAcquire()) {
       dependencies.updateGuard.release(updateId)
       send(response, 503)

package/src/telegram-webhook.js

@@ -2,8 +2,10 @@
 
 import {createServer} from "node:http"
 import {ActivityLog} from "./activity-log.js"
+import {EvidenceStore} from "./evidence-store.js"
 import {buildProviderEnvironment, parseIngressConfig, resolveIngressEnvironment} from "./telegram-ingress/config.js"
 import {createWebhookHandler} from "./telegram-ingress/http.js"
+import {isolatedRuntimeClientFromEnvironment} from "./isolated-runtime-client.js"
 
 /**
  * Start the standalone Threadwire Telegram webhook service.
@@ -15,6 +17,7 @@ import {createWebhookHandler} from "./telegram-ingress/http.js"
  *   onWorkerFailure?: (message: string) => void,
  *   providerEnvironment?: NodeJS.ProcessEnv,
  *   activity?: Pick<ActivityLog, "recordWorkspace" | "recordStarted" | "recordSession" | "close">,
+ *   evidenceStore?: EvidenceStore,
  *   handlerDependencies?: import("./telegram-ingress/http.js").WebhookDependencies
  * }} [options]
  * @returns {Promise<{server: import("node:http").Server, config: import("./telegram-ingress/config.js").IngressConfig, handler: (request: import("node:http").IncomingMessage, response: import("node:http").ServerResponse) => void}>}
@@ -32,16 +35,35 @@ export async function startTelegramWebhook(options = {}) {
   const providerEnvironment = buildProviderEnvironment(
     options.providerEnvironment ?? environment
   )
+  const isolatedConfigured = environment.THREADWIRE_ISOLATED_RUNTIME_URL !== undefined
+    || environment.THREADWIRE_ISOLATED_RUNTIME_CONTROL_TOKEN !== undefined
+  const isolatedRuntimeClient = options.handlerDependencies?.isolatedRuntimeClient
+    ?? (isolatedConfigured ? isolatedRuntimeClientFromEnvironment(environment) : undefined)
   const activity = options.activity ?? options.handlerDependencies?.activity ?? new ActivityLog("/var/lib/threadwire/activity/threadwire.jsonl")
+  const evidenceStore = options.evidenceStore ?? options.handlerDependencies?.evidenceStore ?? await EvidenceStore.open({
+    root: config.evidenceRoot ?? "/var/lib/threadwire/evidence"
+  })
 
   const handler = createWebhookHandler(config, {
     ...options.handlerDependencies,
     activity,
+    evidenceStore,
     providerEnvironment,
+    ...(isolatedRuntimeClient === undefined ? {} : {isolatedRuntimeClient}),
     onOperationalError,
     onWorkerFailure
   })
   const server = createServerImpl(handler)
+  if (options.evidenceStore === undefined && options.handlerDependencies?.evidenceStore === undefined) {
+    const cleanupTimer = setInterval(() => {
+      void evidenceStore.cleanup().catch((error) => onOperationalError(error instanceof Error ? error.message : "Evidence cleanup failed"))
+    }, 60 * 60 * 1000)
+    cleanupTimer.unref()
+    server.once("close", () => {
+      clearInterval(cleanupTimer)
+      void evidenceStore.close()
+    })
+  }
 
   if (options.listen) {
     await options.listen(server, config.port, config.host)

package/src/types.js

@@ -7,8 +7,8 @@
  * @typedef {{type: "diagnostic", level: "warning" | "error", summary: string}} DiagnosticEvent
  * @typedef {TextDeltaEvent | ToolEvent | LifecycleEvent | DiagnosticEvent} WorkerEvent
  * @typedef {{platform: "telegram", chatId: string, threadId: number | null}} TelegramTarget
- * @typedef {{text: string, format?: "javascript-code", label?: string, batchSeparator?: string}} TextNotice
- * @typedef {{activity: {key: string, phase: "started" | "finished"}, text: string, parseMode?: "HTML"}} ActivityNotice
+ * @typedef {{text: string, format?: "javascript-code", label?: string, batchSeparator?: string, metricClass?: string}} TextNotice
+ * @typedef {{activity: {key: string, phase: "started" | "finished"}, text: string, parseMode?: "HTML", metricClass?: string}} ActivityNotice
  * @typedef {TextNotice | ActivityNotice} RenderedNotice
  * @typedef {{text: string, parseMode?: "HTML"}} OutgoingMessage
  * @typedef {{messageId: number}} SentMessage