@dotsetlabs/dotclaw 1.6.0 → 1.7.0

package/README.md

@@ -6,6 +6,8 @@ Personal OpenRouter-based assistant for Telegram. Each request runs inside an is
 
 - Telegram bot interface with per-group isolation
 - Containerized agent runtime with strict mounts
+- Rich Telegram I/O tools (file/photo/voice/audio/location/contact/poll/buttons/edit/delete)
+- Incoming media ingestion to workspace (`/workspace/group/inbox`) for agent processing
 - Long-term memory with embeddings and semantic search
 - Scheduled tasks (cron and one-off)
 - Background jobs for long-running work

package/config-examples/runtime.json

@@ -3,6 +3,7 @@
     "logLevel": "info",
     "container": {
       "mode": "daemon",
+      "privileged": true,
       "instanceId": ""
     },
     "metrics": {

package/config-examples/tool-policy.json

@@ -13,6 +13,17 @@
       "Bash",
       "Python",
       "mcp__dotclaw__send_message",
+      "mcp__dotclaw__send_file",
+      "mcp__dotclaw__send_photo",
+      "mcp__dotclaw__send_voice",
+      "mcp__dotclaw__send_audio",
+      "mcp__dotclaw__send_location",
+      "mcp__dotclaw__send_contact",
+      "mcp__dotclaw__send_poll",
+      "mcp__dotclaw__send_buttons",
+      "mcp__dotclaw__edit_message",
+      "mcp__dotclaw__delete_message",
+      "mcp__dotclaw__download_url",
       "mcp__dotclaw__schedule_task",
       "mcp__dotclaw__run_task",
       "mcp__dotclaw__list_tasks",

package/container/Dockerfile

@@ -23,11 +23,15 @@ RUN apt-get update && apt-get install -y \
     libxshmfence1 \
     curl \
     git \
+    sudo \
     python3 \
     python3-pip \
     python3-venv \
     && rm -rf /var/lib/apt/lists/*
 
+# Allow the node user to install system packages via sudo
+RUN echo 'node ALL=(ALL) NOPASSWD: ALL' > /etc/sudoers.d/node && chmod 0440 /etc/sudoers.d/node
+
 # Install common Python packages
 RUN pip3 install --break-system-packages pandas numpy requests beautifulsoup4 matplotlib
 

package/container/agent-runner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotclaw-agent-runner",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "type": "module",
   "description": "Container-side agent runner for DotClaw",
   "main": "dist/index.js",

package/container/agent-runner/src/agent-config.ts

@@ -3,6 +3,7 @@ import fs from 'fs';
 export type AgentRuntimeConfig = {
   defaultModel: string;
   daemonPollMs: number;
+  daemonHeartbeatIntervalMs: number;
   agent: {
     assistantName: string;
     openrouter: {
@@ -118,6 +119,7 @@ export type AgentRuntimeConfig = {
 const CONFIG_PATH = '/workspace/config/runtime.json';
 const DEFAULT_DEFAULT_MODEL = 'moonshotai/kimi-k2.5';
 const DEFAULT_DAEMON_POLL_MS = 200;
+const DEFAULT_DAEMON_HEARTBEAT_INTERVAL_MS = 1_000;
 
 const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
   assistantName: 'Rain',
@@ -279,6 +281,7 @@ export function loadAgentConfig(): AgentRuntimeConfig {
 
   let defaultModel = DEFAULT_DEFAULT_MODEL;
   let daemonPollMs = DEFAULT_DAEMON_POLL_MS;
+  let daemonHeartbeatIntervalMs = DEFAULT_DAEMON_HEARTBEAT_INTERVAL_MS;
   let agentOverrides: unknown = null;
 
   if (isPlainObject(raw)) {
@@ -288,8 +291,13 @@ export function loadAgentConfig(): AgentRuntimeConfig {
         defaultModel = host.defaultModel.trim();
       }
       const container = host.container;
-      if (isPlainObject(container) && typeof container.daemonPollMs === 'number') {
-        daemonPollMs = container.daemonPollMs;
+      if (isPlainObject(container)) {
+        if (typeof container.daemonPollMs === 'number') {
+          daemonPollMs = container.daemonPollMs;
+        }
+        if (typeof container.daemonHeartbeatIntervalMs === 'number') {
+          daemonHeartbeatIntervalMs = container.daemonHeartbeatIntervalMs;
+        }
       }
     }
     if (isPlainObject(raw.agent)) {
@@ -300,6 +308,7 @@ export function loadAgentConfig(): AgentRuntimeConfig {
   cachedConfig = {
     defaultModel,
     daemonPollMs,
+    daemonHeartbeatIntervalMs,
     agent: mergeDefaults(DEFAULT_AGENT_CONFIG, agentOverrides)
   };
   return cachedConfig;

package/container/agent-runner/src/container-protocol.ts

@@ -45,6 +45,16 @@ export interface ContainerInput {
   disableResponseValidation?: boolean;
   responseValidationMaxRetries?: number;
   disableMemoryExtraction?: boolean;
+  attachments?: Array<{
+    type: 'photo' | 'document' | 'voice' | 'video' | 'audio';
+    path: string;
+    file_name?: string;
+    mime_type?: string;
+    file_size?: number;
+    duration?: number;
+    width?: number;
+    height?: number;
+  }>;
 }
 
 export interface ContainerOutput {

package/container/agent-runner/src/daemon.ts

@@ -1,13 +1,21 @@
 import fs from 'fs';
 import path from 'path';
-import { runAgentOnce } from './index.js';
+import { Worker } from 'worker_threads';
+import { fileURLToPath } from 'url';
 import { loadAgentConfig } from './agent-config.js';
-import type { ContainerInput } from './container-protocol.js';
+import type { ContainerInput, ContainerOutput } from './container-protocol.js';
 
 const REQUESTS_DIR = '/workspace/ipc/agent_requests';
 const RESPONSES_DIR = '/workspace/ipc/agent_responses';
 const HEARTBEAT_FILE = '/workspace/ipc/heartbeat';
-const POLL_MS = loadAgentConfig().daemonPollMs;
+const STATUS_FILE = '/workspace/ipc/daemon_status.json';
+
+const config = loadAgentConfig();
+const POLL_MS = config.daemonPollMs;
+const HEARTBEAT_INTERVAL_MS = config.daemonHeartbeatIntervalMs;
+
+let shuttingDown = false;
+let heartbeatWorker: Worker | null = null;
 
 function log(message: string): void {
   console.error(`[agent-daemon] ${message}`);
@@ -18,66 +26,263 @@ function ensureDirs(): void {
   fs.mkdirSync(RESPONSES_DIR, { recursive: true });
 }
 
-function writeHeartbeat(): void {
+// --- Worker thread management ---
+
+function getWorkerPath(): string {
+  const thisFile = fileURLToPath(import.meta.url);
+  return path.join(path.dirname(thisFile), 'heartbeat-worker.js');
+}
+
+function getRequestWorkerPath(): string {
+  const thisFile = fileURLToPath(import.meta.url);
+  return path.join(path.dirname(thisFile), 'request-worker.js');
+}
+
+let workerRestarts = 0;
+let workerRestartWindowStart = Date.now();
+let workerRestarting = false;
+
+function maybeRestartWorker(exitCode: number): void {
+  if (shuttingDown || exitCode === 0 || workerRestarting) return;
+  workerRestarting = true;
+  const now = Date.now();
+  if (now - workerRestartWindowStart > 60_000) {
+    workerRestarts = 0;
+    workerRestartWindowStart = now;
+  }
+  workerRestarts++;
+  if (workerRestarts > 5) {
+    log('Heartbeat worker crash loop detected, stopping restarts');
+    workerRestarting = false;
+    return;
+  }
+  const delay = Math.min(1000 * Math.pow(2, workerRestarts - 1), 10_000);
+  setTimeout(() => {
+    workerRestarting = false;
+    heartbeatWorker = spawnHeartbeatWorker();
+  }, delay);
+}
+
+function spawnHeartbeatWorker(): Worker {
+  const workerPath = getWorkerPath();
+  const worker = new Worker(workerPath, {
+    workerData: {
+      heartbeatPath: HEARTBEAT_FILE,
+      statusPath: STATUS_FILE,
+      intervalMs: HEARTBEAT_INTERVAL_MS,
+      pid: process.pid,
+    },
+  });
+
+  worker.on('error', (err) => {
+    log(`Heartbeat worker error: ${err.message}`);
+    maybeRestartWorker(1);
+  });
+
+  worker.on('exit', (code) => {
+    if (code !== 0) {
+      log(`Heartbeat worker exited with code ${code}`);
+    }
+    maybeRestartWorker(code ?? 1);
+  });
+
+  return worker;
+}
+
+function postWorkerMessage(msg: { type: string; requestId?: string }): void {
   try {
-    fs.writeFileSync(HEARTBEAT_FILE, Date.now().toString());
+    heartbeatWorker?.postMessage(msg);
   } catch {
-    // Ignore heartbeat write errors
+    // Worker may have died — will be restarted by exit handler
   }
 }
 
+let currentRequestId: string | null = null;
+
+async function runRequestWithCancellation(requestId: string, input: ContainerInput): Promise<{ output: ContainerOutput | null; canceled: boolean }> {
+  const cancelFile = path.join(REQUESTS_DIR, requestId + '.cancel');
+  const workerPath = getRequestWorkerPath();
+  const worker = new Worker(workerPath, { workerData: { input } });
+
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+
+    const finish = (fn: () => void): void => {
+      if (settled) return;
+      settled = true;
+      clearInterval(cancelTimer);
+      fn();
+    };
+
+    const handleCancel = (): void => {
+      if (!fs.existsSync(cancelFile)) return;
+      finish(() => {
+        try { fs.unlinkSync(cancelFile); } catch { /* already removed */ }
+        void worker.terminate().catch(() => undefined);
+        resolve({ output: null, canceled: true });
+      });
+    };
+
+    const cancelTimer = setInterval(handleCancel, Math.max(100, Math.floor(POLL_MS / 2)));
+    handleCancel();
+
+    worker.on('message', (message: unknown) => {
+      finish(() => {
+        const payload = (message && typeof message === 'object') ? (message as Record<string, unknown>) : null;
+        if (payload?.ok === true && payload.output && typeof payload.output === 'object') {
+          resolve({ output: payload.output as ContainerOutput, canceled: false });
+          return;
+        }
+        const errMessage = typeof payload?.error === 'string' ? payload.error : 'Agent worker failed';
+        reject(new Error(errMessage));
+      });
+    });
+
+    worker.on('error', (err) => {
+      finish(() => reject(err));
+    });
+
+    worker.on('exit', (code) => {
+      finish(() => {
+        if (code === 0) {
+          reject(new Error('Agent worker exited without output'));
+          return;
+        }
+        reject(new Error(`Agent worker exited with code ${code}`));
+      });
+    });
+  });
+}
+
+// --- Request processing ---
+
+function isContainerInput(value: unknown): value is ContainerInput {
+  if (!value || typeof value !== 'object') return false;
+  const record = value as Record<string, unknown>;
+  return typeof record.prompt === 'string'
+    && typeof record.groupFolder === 'string'
+    && typeof record.chatJid === 'string'
+    && typeof record.isMain === 'boolean';
+}
+
 async function processRequests(): Promise<void> {
-  const files = fs.readdirSync(REQUESTS_DIR).filter(file => file.endsWith('.json'));
+  const files = fs.readdirSync(REQUESTS_DIR).filter(file => file.endsWith('.json')).sort();
   for (const file of files) {
+    if (shuttingDown) break;
+
     const filePath = path.join(REQUESTS_DIR, file);
     let requestId = file.replace('.json', '');
+    const cancelFile = path.join(REQUESTS_DIR, requestId + '.cancel');
+    if (fs.existsSync(cancelFile)) {
+      try { fs.unlinkSync(filePath); } catch { /* already removed */ }
+      try { fs.unlinkSync(cancelFile); } catch { /* already removed */ }
+      continue;
+    }
     try {
-      const raw = fs.readFileSync(filePath, 'utf-8');
+      let raw: string;
+      try {
+        raw = fs.readFileSync(filePath, 'utf-8');
+      } catch (readErr) {
+        if ((readErr as NodeJS.ErrnoException).code === 'ENOENT') continue;
+        throw readErr;
+      }
       const payload = JSON.parse(raw) as { id?: string; input?: unknown };
       requestId = payload.id || requestId;
       const input = payload.input || payload;
       if (!isContainerInput(input)) {
         throw new Error('Invalid agent request payload');
       }
-      const output = await runAgentOnce(input);
+
+      currentRequestId = requestId;
+      postWorkerMessage({ type: 'processing', requestId });
+
+      const { output, canceled } = await runRequestWithCancellation(requestId, input);
+      if (canceled) {
+        try { fs.unlinkSync(filePath); } catch { /* request file already removed */ }
+        continue;
+      }
+      if (!output) {
+        throw new Error('Agent worker returned no output');
+      }
+      if (fs.existsSync(cancelFile)) {
+        try { fs.unlinkSync(cancelFile); } catch { /* already removed */ }
+        try { fs.unlinkSync(filePath); } catch { /* request file already removed */ }
+        continue;
+      }
       const responsePath = path.join(RESPONSES_DIR, `${requestId}.json`);
-      fs.writeFileSync(responsePath, JSON.stringify(output));
-      fs.unlinkSync(filePath);
+      const tmpPath = responsePath + '.tmp';
+      fs.writeFileSync(tmpPath, JSON.stringify(output));
+      fs.renameSync(tmpPath, responsePath);
+      try { fs.unlinkSync(filePath); } catch { /* request file already removed */ }
     } catch (err) {
       log(`Failed processing request ${requestId}: ${err instanceof Error ? err.message : String(err)}`);
       const responsePath = path.join(RESPONSES_DIR, `${requestId}.json`);
-      fs.writeFileSync(responsePath, JSON.stringify({
+      const tmpPath = responsePath + '.tmp';
+      fs.writeFileSync(tmpPath, JSON.stringify({
         status: 'error',
         result: null,
         error: err instanceof Error ? err.message : String(err)
       }));
-      try {
-        fs.unlinkSync(filePath);
-      } catch {
-        // ignore cleanup failure
-      }
+      fs.renameSync(tmpPath, responsePath);
+      try { fs.unlinkSync(filePath); } catch { /* request file already removed */ }
+    } finally {
+      currentRequestId = null;
+      postWorkerMessage({ type: 'idle' });
     }
   }
 }
 
-function isContainerInput(value: unknown): value is ContainerInput {
-  if (!value || typeof value !== 'object') return false;
-  const record = value as Record<string, unknown>;
-  return typeof record.prompt === 'string'
-    && typeof record.groupFolder === 'string'
-    && typeof record.chatJid === 'string'
-    && typeof record.isMain === 'boolean';
+// --- Graceful shutdown ---
+
+function shutdown(signal: string): void {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log(`Received ${signal}, shutting down gracefully...`);
+  postWorkerMessage({ type: 'shutdown' });
+  const deadline = Date.now() + 30_000;
+  const check = () => {
+    if (!currentRequestId || Date.now() > deadline) {
+      if (currentRequestId) {
+        // Write aborted response for in-flight request
+        const responsePath = path.join(RESPONSES_DIR, `${currentRequestId}.json`);
+        try {
+          const tmpPath = responsePath + '.tmp';
+          fs.writeFileSync(tmpPath, JSON.stringify({ status: 'error', result: null, error: 'Daemon shutting down' }));
+          fs.renameSync(tmpPath, responsePath);
+        } catch { /* best-effort abort response */ }
+      }
+      log('Daemon stopped.');
+      process.exit(0);
+    }
+    setTimeout(check, 500);
+  };
+  check();
 }
 
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));
+
+// --- Error handlers (keep daemon alive through individual failures) ---
+
+process.on('unhandledRejection', (reason) => {
+  log(`Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
+  // Don't exit — daemon should survive individual request failures
+});
+
+process.on('uncaughtException', (err) => {
+  log(`Uncaught exception (fatal): ${err.message}`);
+  try { postWorkerMessage({ type: 'shutdown' }); } catch { /* worker may be dead */ }
+  process.exit(1);
+});
+
+// --- Main loop ---
+
 async function loop(): Promise<void> {
   ensureDirs();
-  log('Daemon started');
-  const heartbeatIntervalMs = Math.max(1000, Math.min(POLL_MS, 10_000));
-  const heartbeatTimer = setInterval(writeHeartbeat, heartbeatIntervalMs);
-  while (true) {
-    // Write heartbeat at the start of each loop iteration
-    writeHeartbeat();
+  heartbeatWorker = spawnHeartbeatWorker();
+  log('Daemon started (worker thread heartbeat active)');
 
+  while (!shuttingDown) {
     try {
       await processRequests();
     } catch (err) {
@@ -85,8 +290,8 @@ async function loop(): Promise<void> {
     }
     await new Promise(resolve => setTimeout(resolve, POLL_MS));
   }
-  // Unreachable, but keep for clarity if loop ever exits
-  clearInterval(heartbeatTimer);
+
+  log('Daemon loop exited.');
 }
 
 loop().catch(err => {

package/container/agent-runner/src/heartbeat-worker.ts

@@ -0,0 +1,94 @@
+/**
+ * Heartbeat Worker Thread
+ *
+ * Runs in a separate V8 isolate so heartbeat writes are never blocked
+ * by long-running agent tasks on the main thread. Writes two files:
+ *
+ * - /workspace/ipc/heartbeat          — epoch ms (backward compatible)
+ * - /workspace/ipc/daemon_status.json — structured status with state info
+ */
+
+import { parentPort, workerData } from 'worker_threads';
+import fs from 'fs';
+
+interface WorkerConfig {
+  heartbeatPath: string;
+  statusPath: string;
+  intervalMs: number;
+  pid: number;
+}
+
+type WorkerMessage =
+  | { type: 'processing'; requestId: string }
+  | { type: 'idle' }
+  | { type: 'shutdown' };
+
+interface DaemonStatus {
+  state: 'idle' | 'processing';
+  ts: number;
+  request_id: string | null;
+  started_at: number | null;
+  pid: number;
+}
+
+const config = workerData as WorkerConfig;
+let state: 'idle' | 'processing' = 'idle';
+let requestId: string | null = null;
+let startedAt: number | null = null;
+function writeHeartbeat(): void {
+  const now = Date.now();
+  try {
+    const tmpHeartbeat = config.heartbeatPath + '.tmp';
+    fs.writeFileSync(tmpHeartbeat, now.toString());
+    fs.renameSync(tmpHeartbeat, config.heartbeatPath);
+  } catch {
+    // Ignore heartbeat write errors
+  }
+
+  const status: DaemonStatus = {
+    state,
+    ts: now,
+    request_id: requestId,
+    started_at: startedAt,
+    pid: config.pid,
+  };
+  try {
+    const tmpStatus = config.statusPath + '.tmp';
+    fs.writeFileSync(tmpStatus, JSON.stringify(status));
+    fs.renameSync(tmpStatus, config.statusPath);
+  } catch {
+    // Ignore status write errors
+  }
+}
+
+// Write immediately on start
+writeHeartbeat();
+
+const timer = setInterval(writeHeartbeat, config.intervalMs);
+
+parentPort?.on('message', (msg: WorkerMessage) => {
+  switch (msg.type) {
+    case 'processing':
+      state = 'processing';
+      requestId = msg.requestId;
+      startedAt = Date.now();
+      writeHeartbeat(); // Immediate update
+      break;
+    case 'idle':
+      state = 'idle';
+      requestId = null;
+      startedAt = null;
+      writeHeartbeat(); // Immediate update
+      break;
+    case 'shutdown':
+      clearInterval(timer);
+      state = 'idle';
+      requestId = null;
+      startedAt = null;
+      writeHeartbeat(); // Final heartbeat
+      process.exit(0);
+      break;
+  }
+});
+
+// Worker stays alive via the setInterval timer