@dotsetlabs/dotclaw 1.5.2 → 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
@@ -45,9 +47,6 @@ After installation, use the `dotclaw` CLI:
 ```bash
 dotclaw setup        # Full setup (init + configure + build + install service)
 dotclaw configure    # Re-configure API keys and model
-dotclaw add-instance # Create and start an isolated instance
-dotclaw instances    # List discovered instances
-dotclaw build        # Build the Docker container image
 dotclaw start        # Start the service
 dotclaw stop         # Stop the service
 dotclaw restart      # Restart the service
@@ -55,6 +54,12 @@ dotclaw logs         # View logs (add --follow to tail)
 dotclaw status       # Show service status
 dotclaw doctor       # Run diagnostics
 dotclaw register     # Register a new Telegram chat
+dotclaw unregister   # Remove a registered Telegram chat
+dotclaw groups       # List registered Telegram chats
+dotclaw build        # Build the Docker container image
+dotclaw add-instance # Create and start an isolated instance
+dotclaw instances    # List discovered instances
+dotclaw version      # Show installed version
 ```
 
 Instance flags:

package/config-examples/runtime.json

@@ -3,6 +3,7 @@
     "logLevel": "info",
     "container": {
       "mode": "daemon",
+      "privileged": true,
       "instanceId": ""
     },
     "metrics": {
@@ -10,7 +11,8 @@
       "enabled": true
     },
     "dashboard": {
-      "enabled": true
+      "enabled": true,
+      "port": 3002
     },
     "memory": {
       "embeddings": {
@@ -54,9 +56,9 @@
       "maxFastChars": 200,
       "maxStandardChars": 1200,
       "backgroundMinChars": 2000,
-      "fastKeywords": ["hi", "hello", "hey", "who are you", "what can you do"],
-      "deepKeywords": ["research", "analysis", "report", "dashboard", "refactor", "architecture", "design"],
-      "backgroundKeywords": ["background", "long-running", "research", "dashboard", "refactor", "report"],
+      "fastKeywords": ["hi", "hello", "hey", "who are you", "what can you do", "help", "thanks", "thank you"],
+      "deepKeywords": ["research", "analysis", "analyze", "report", "dashboard", "vibe", "refactor", "architecture", "design", "spec", "strategy", "migration", "benchmark", "investigate", "evaluate", "summarize", "long-running"],
+      "backgroundKeywords": ["background", "long-running", "research", "deep dive", "multi-step", "multi step", "dashboard", "refactor", "benchmark", "report", "analysis", "survey", "crawl", "scrape", "codebase"],
       "classifierFallback": {
         "enabled": true,
         "minChars": 600
@@ -74,7 +76,7 @@
       "profiles": {
         "fast": {
           "model": "openai/gpt-5-nano",
-          "maxOutputTokens": 256,
+          "maxOutputTokens": 4096,
           "maxToolSteps": 6,
           "recallMaxResults": 0,
           "recallMaxTokens": 0,
@@ -87,7 +89,7 @@
         },
         "standard": {
           "model": "openai/gpt-5-mini",
-          "maxOutputTokens": 768,
+          "maxOutputTokens": 4096,
           "maxToolSteps": 16,
           "recallMaxResults": 6,
           "recallMaxTokens": 1500,
@@ -99,7 +101,7 @@
         },
         "deep": {
           "model": "moonshotai/kimi-k2.5",
-          "maxOutputTokens": 1536,
+          "maxOutputTokens": 4096,
           "maxToolSteps": 32,
           "recallMaxResults": 12,
           "recallMaxTokens": 2500,
@@ -111,7 +113,7 @@
         },
         "background": {
           "model": "moonshotai/kimi-k2.5",
-          "maxOutputTokens": 2048,
+          "maxOutputTokens": 4096,
           "maxToolSteps": 64,
           "recallMaxResults": 16,
           "recallMaxTokens": 4000,

package/config-examples/tool-policy.json

@@ -13,12 +13,29 @@
       "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",
       "mcp__dotclaw__pause_task",
       "mcp__dotclaw__resume_task",
       "mcp__dotclaw__cancel_task",
       "mcp__dotclaw__update_task",
+      "mcp__dotclaw__spawn_job",
+      "mcp__dotclaw__job_status",
+      "mcp__dotclaw__list_jobs",
+      "mcp__dotclaw__cancel_job",
+      "mcp__dotclaw__job_update",
       "mcp__dotclaw__register_group",
       "mcp__dotclaw__remove_group",
       "mcp__dotclaw__list_groups",

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-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "dotclaw-agent-runner",
-  "version": "1.5.2",
+  "version": "1.6.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "dotclaw-agent-runner",
-      "version": "1.5.2",
+      "version": "1.6.0",
       "dependencies": {
         "@openrouter/sdk": "^0.3.0",
         "cron-parser": "^5.0.0",

package/container/agent-runner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dotclaw-agent-runner",
-  "version": "1.5.2",
+  "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: {
@@ -103,10 +104,6 @@ export type AgentRuntimeConfig = {
         tools: string[];
       };
     };
-    streaming: {
-      minIntervalMs: number;
-      minChars: number;
-    };
     ipc: {
       requestTimeoutMs: number;
       requestPollMs: number;
@@ -122,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',
@@ -143,7 +141,7 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
     recentContextTokens: 8000,
     summaryUpdateEveryMessages: 20,
     maxOutputTokens: 1024,
-    summaryMaxOutputTokens: 600,
+    summaryMaxOutputTokens: 2048,
     temperature: 0.2,
     maxContextMessageTokens: 3000
   },
@@ -154,7 +152,7 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
       enabled: true,
       async: true,
       maxMessages: 4,
-      maxOutputTokens: 200
+      maxOutputTokens: 1024
     },
     archiveSync: true,
     extractScheduled: false
@@ -171,12 +169,12 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
     mode: 'auto',
     minTokens: 800,
     triggerRegex: '(plan|steps|roadmap|research|design|architecture|spec|strategy)',
-    maxOutputTokens: 200,
+    maxOutputTokens: 1024,
     temperature: 0.2
   },
   responseValidation: {
     enabled: true,
-    maxOutputTokens: 120,
+    maxOutputTokens: 1024,
     temperature: 0,
     maxRetries: 1,
     allowToolCalls: false,
@@ -223,10 +221,6 @@ const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
       tools: ['WebFetch']
     }
   },
-  streaming: {
-    minIntervalMs: 800,
-    minChars: 120
-  },
   ipc: {
     requestTimeoutMs: 6000,
     requestPollMs: 150
@@ -275,7 +269,8 @@ function readJson(filePath: string): unknown {
     const raw = fs.readFileSync(filePath, 'utf-8');
     if (!raw.trim()) return null;
     return JSON.parse(raw);
-  } catch {
+  } catch (err) {
+    console.error(`[agent-runner] Failed to load config ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
     return null;
   }
 }
@@ -286,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)) {
@@ -295,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)) {
@@ -307,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,12 +45,16 @@ export interface ContainerInput {
   disableResponseValidation?: boolean;
   responseValidationMaxRetries?: number;
   disableMemoryExtraction?: boolean;
-  streaming?: {
-    enabled?: boolean;
-    draftId?: number;
-    minIntervalMs?: number;
-    minChars?: number;
-  };
+  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 => {