@dotsetlabs/dotclaw 1.1.0

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

@@ -0,0 +1,295 @@
+import fs from 'fs';
+
+export type AgentRuntimeConfig = {
+  defaultModel: string;
+  daemonPollMs: number;
+  agent: {
+    assistantName: string;
+    openrouter: {
+      timeoutMs: number;
+      retry: boolean;
+      siteUrl: string;
+      siteName: string;
+    };
+    promptPacks: {
+      enabled: boolean;
+      maxChars: number;
+      maxDemos: number;
+      canaryRate: number;
+    };
+    context: {
+      maxContextTokens: number;
+      compactionTriggerTokens: number;
+      recentContextTokens: number;
+      summaryUpdateEveryMessages: number;
+      maxOutputTokens: number;
+      summaryMaxOutputTokens: number;
+      temperature: number;
+      maxContextMessageTokens: number;
+    };
+    memory: {
+      maxResults: number;
+      maxTokens: number;
+      extraction: {
+        enabled: boolean;
+        async: boolean;
+        maxMessages: number;
+        maxOutputTokens: number;
+      };
+      archiveSync: boolean;
+      extractScheduled: boolean;
+    };
+    models: {
+      summary: string;
+      memory: string;
+      planner: string;
+      responseValidation: string;
+      toolSummary: string;
+    };
+    planner: {
+      enabled: boolean;
+      mode: string;
+      minTokens: number;
+      triggerRegex: string;
+      maxOutputTokens: number;
+      temperature: number;
+    };
+    responseValidation: {
+      enabled: boolean;
+      maxOutputTokens: number;
+      temperature: number;
+      maxRetries: number;
+      allowToolCalls: boolean;
+    };
+    tools: {
+      maxToolSteps: number;
+      outputLimitBytes: number;
+      enableBash: boolean;
+      enableWebSearch: boolean;
+      enableWebFetch: boolean;
+      webfetch: {
+        blockPrivate: boolean;
+        allowlist: string[];
+        blocklist: string[];
+        maxBytes: number;
+        timeoutMs: number;
+      };
+      websearch: {
+        timeoutMs: number;
+      };
+      bash: {
+        timeoutMs: number;
+        outputLimitBytes: number;
+      };
+      grepMaxFileBytes: number;
+      plugin: {
+        dirs: string[];
+        maxBytes: number;
+        httpTimeoutMs: number;
+      };
+      toolSummary: {
+        enabled: boolean;
+        maxBytes: number;
+        maxOutputTokens: number;
+        tools: string[];
+      };
+    };
+    streaming: {
+      minIntervalMs: number;
+      minChars: number;
+    };
+    ipc: {
+      requestTimeoutMs: number;
+      requestPollMs: number;
+    };
+    tokenEstimate: {
+      tokensPerChar: number;
+      tokensPerMessage: number;
+      tokensPerRequest: number;
+    };
+  };
+};
+
+const CONFIG_PATH = '/workspace/config/runtime.json';
+const DEFAULT_DEFAULT_MODEL = 'moonshotai/kimi-k2.5';
+const DEFAULT_DAEMON_POLL_MS = 200;
+
+const DEFAULT_AGENT_CONFIG: AgentRuntimeConfig['agent'] = {
+  assistantName: 'Rain',
+  openrouter: {
+    timeoutMs: 180_000,
+    retry: true,
+    siteUrl: '',
+    siteName: ''
+  },
+  promptPacks: {
+    enabled: true,
+    maxChars: 6000,
+    maxDemos: 4,
+    canaryRate: 0.1
+  },
+  context: {
+    maxContextTokens: 24_000,
+    compactionTriggerTokens: 20_000,
+    recentContextTokens: 8000,
+    summaryUpdateEveryMessages: 20,
+    maxOutputTokens: 1024,
+    summaryMaxOutputTokens: 600,
+    temperature: 0.2,
+    maxContextMessageTokens: 3000
+  },
+  memory: {
+    maxResults: 6,
+    maxTokens: 2000,
+    extraction: {
+      enabled: true,
+      async: true,
+      maxMessages: 4,
+      maxOutputTokens: 200
+    },
+    archiveSync: true,
+    extractScheduled: false
+  },
+  models: {
+    summary: 'openai/gpt-5-nano',
+    memory: 'openai/gpt-5-mini',
+    planner: 'openai/gpt-5-nano',
+    responseValidation: 'openai/gpt-5-nano',
+    toolSummary: 'openai/gpt-5-nano'
+  },
+  planner: {
+    enabled: true,
+    mode: 'auto',
+    minTokens: 600,
+    triggerRegex: '(plan|steps|roadmap|research|design|architecture|spec|strategy)',
+    maxOutputTokens: 200,
+    temperature: 0.2
+  },
+  responseValidation: {
+    enabled: true,
+    maxOutputTokens: 120,
+    temperature: 0,
+    maxRetries: 1,
+    allowToolCalls: false
+  },
+  tools: {
+    maxToolSteps: 24,
+    outputLimitBytes: 400_000,
+    enableBash: true,
+    enableWebSearch: true,
+    enableWebFetch: true,
+    webfetch: {
+      blockPrivate: true,
+      allowlist: [],
+      blocklist: ['localhost', '127.0.0.1'],
+      maxBytes: 300_000,
+      timeoutMs: 20_000
+    },
+    websearch: {
+      timeoutMs: 20_000
+    },
+    bash: {
+      timeoutMs: 120_000,
+      outputLimitBytes: 200_000
+    },
+    grepMaxFileBytes: 1_000_000,
+    plugin: {
+      dirs: [],
+      maxBytes: 800_000,
+      httpTimeoutMs: 20_000
+    },
+    toolSummary: {
+      enabled: true,
+      maxBytes: 60_000,
+      maxOutputTokens: 400,
+      tools: ['WebFetch']
+    }
+  },
+  streaming: {
+    minIntervalMs: 800,
+    minChars: 120
+  },
+  ipc: {
+    requestTimeoutMs: 6000,
+    requestPollMs: 150
+  },
+  tokenEstimate: {
+    tokensPerChar: 0.25,
+    tokensPerMessage: 3,
+    tokensPerRequest: 0
+  }
+};
+
+let cachedConfig: AgentRuntimeConfig | null = null;
+
+function cloneConfig<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function mergeDefaults<T>(base: T, overrides: unknown): T {
+  if (!isPlainObject(overrides)) return cloneConfig(base);
+  const result = cloneConfig(base) as Record<string, unknown>;
+  const baseObj = base as Record<string, unknown>;
+  for (const [key, value] of Object.entries(overrides)) {
+    const current = baseObj[key];
+    if (isPlainObject(current) && isPlainObject(value)) {
+      result[key] = mergeDefaults(current, value);
+      continue;
+    }
+    if (Array.isArray(current) && Array.isArray(value)) {
+      result[key] = value;
+      continue;
+    }
+    if (typeof value === typeof current) {
+      result[key] = value as unknown;
+    }
+  }
+  return result as T;
+}
+
+function readJson(filePath: string): unknown {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    if (!raw.trim()) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function loadAgentConfig(): AgentRuntimeConfig {
+  if (cachedConfig) return cachedConfig;
+  const raw = readJson(CONFIG_PATH);
+
+  let defaultModel = DEFAULT_DEFAULT_MODEL;
+  let daemonPollMs = DEFAULT_DAEMON_POLL_MS;
+  let agentOverrides: unknown = null;
+
+  if (isPlainObject(raw)) {
+    const host = raw.host;
+    if (isPlainObject(host)) {
+      if (typeof host.defaultModel === 'string' && host.defaultModel.trim()) {
+        defaultModel = host.defaultModel.trim();
+      }
+      const container = host.container;
+      if (isPlainObject(container) && typeof container.daemonPollMs === 'number') {
+        daemonPollMs = container.daemonPollMs;
+      }
+    }
+    if (isPlainObject(raw.agent)) {
+      agentOverrides = raw.agent;
+    }
+  }
+
+  cachedConfig = {
+    defaultModel,
+    daemonPollMs,
+    agent: mergeDefaults(DEFAULT_AGENT_CONFIG, agentOverrides)
+  };
+  return cachedConfig;
+}

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

@@ -0,0 +1,73 @@
+export const OUTPUT_START_MARKER = '---DOTCLAW_OUTPUT_START---';
+export const OUTPUT_END_MARKER = '---DOTCLAW_OUTPUT_END---';
+
+export interface ContainerInput {
+  prompt: string;
+  sessionId?: string;
+  groupFolder: string;
+  chatJid: string;
+  isMain: boolean;
+  isScheduledTask?: boolean;
+  isBackgroundTask?: boolean;
+  taskId?: string;
+  userId?: string;
+  userName?: string;
+  memoryRecall?: string[];
+  userProfile?: string | null;
+  memoryStats?: {
+    total: number;
+    user: number;
+    group: number;
+    global: number;
+  };
+  tokenEstimate?: {
+    tokens_per_char: number;
+    tokens_per_message: number;
+    tokens_per_request: number;
+  };
+  toolReliability?: Array<{
+    name: string;
+    success_rate: number;
+    count: number;
+    avg_duration_ms: number | null;
+  }>;
+  behaviorConfig?: Record<string, unknown>;
+  toolPolicy?: Record<string, unknown>;
+  modelOverride?: string;
+  modelContextTokens?: number;
+  modelMaxOutputTokens?: number;
+  modelTemperature?: number;
+  streaming?: {
+    enabled?: boolean;
+    draftId?: number;
+    minIntervalMs?: number;
+    minChars?: number;
+  };
+}
+
+export interface ContainerOutput {
+  status: 'success' | 'error';
+  result: string | null;
+  newSessionId?: string;
+  error?: string;
+  model?: string;
+  prompt_pack_versions?: Record<string, string>;
+  memory_summary?: string;
+  memory_facts?: string[];
+  tokens_prompt?: number;
+  tokens_completion?: number;
+  memory_recall_count?: number;
+  session_recall_count?: number;
+  memory_items_upserted?: number;
+  memory_items_extracted?: number;
+  tool_calls?: Array<{
+    name: string;
+    args?: unknown;
+    ok: boolean;
+    duration_ms?: number;
+    error?: string;
+    output_bytes?: number;
+    output_truncated?: boolean;
+  }>;
+  latency_ms?: number;
+}

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

@@ -0,0 +1,91 @@
+import fs from 'fs';
+import path from 'path';
+import { runAgentOnce } from './index.js';
+import { loadAgentConfig } from './agent-config.js';
+import type { ContainerInput } 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;
+
+function log(message: string): void {
+  console.error(`[agent-daemon] ${message}`);
+}
+
+function ensureDirs(): void {
+  fs.mkdirSync(REQUESTS_DIR, { recursive: true });
+  fs.mkdirSync(RESPONSES_DIR, { recursive: true });
+}
+
+function writeHeartbeat(): void {
+  try {
+    fs.writeFileSync(HEARTBEAT_FILE, Date.now().toString());
+  } catch {
+    // Ignore heartbeat write errors
+  }
+}
+
+async function processRequests(): Promise<void> {
+  const files = fs.readdirSync(REQUESTS_DIR).filter(file => file.endsWith('.json'));
+  for (const file of files) {
+    const filePath = path.join(REQUESTS_DIR, file);
+    let requestId = file.replace('.json', '');
+    try {
+      const raw = fs.readFileSync(filePath, 'utf-8');
+      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);
+      const responsePath = path.join(RESPONSES_DIR, `${requestId}.json`);
+      fs.writeFileSync(responsePath, JSON.stringify(output));
+      fs.unlinkSync(filePath);
+    } 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({
+        status: 'error',
+        result: null,
+        error: err instanceof Error ? err.message : String(err)
+      }));
+      try {
+        fs.unlinkSync(filePath);
+      } catch {
+        // ignore cleanup failure
+      }
+    }
+  }
+}
+
+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 loop(): Promise<void> {
+  ensureDirs();
+  log('Daemon started');
+  while (true) {
+    // Write heartbeat at the start of each loop iteration
+    writeHeartbeat();
+
+    try {
+      await processRequests();
+    } catch (err) {
+      log(`Daemon loop error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    await new Promise(resolve => setTimeout(resolve, POLL_MS));
+  }
+}
+
+loop().catch(err => {
+  log(`Daemon fatal error: ${err instanceof Error ? err.message : String(err)}`);
+  process.exit(1);
+});