@hybridaione/hybridclaw 0.1.5

package/container/package-lock.json

@@ -0,0 +1,246 @@
+{
+  "name": "hybridclaw-agent",
+  "version": "0.1.5",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "hybridclaw-agent",
+      "version": "0.1.5",
+      "dependencies": {
+        "@mozilla/readability": "^0.6.0",
+        "linkedom": "^0.18.12"
+      },
+      "devDependencies": {
+        "@types/node": "^22.10.0",
+        "typescript": "^5.7.0"
+      }
+    },
+    "node_modules/@mozilla/readability": {
+      "version": "0.6.0",
+      "resolved": "https://registry.npmjs.org/@mozilla/readability/-/readability-0.6.0.tgz",
+      "integrity": "sha512-juG5VWh4qAivzTAeMzvY9xs9HY5rAcr2E4I7tiSSCokRFi7XIZCAu92ZkSTsIj1OPceCifL3cpfteP3pDT9/QQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "22.19.11",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.11.tgz",
+      "integrity": "sha512-BH7YwL6rA93ReqeQS1c4bsPpcfOmJasG+Fkr6Y59q83f9M1WcBRHR2vM+P9eOisYRcN3ujQoiZY8uk5W+1WL8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/boolbase": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz",
+      "integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
+      "license": "ISC"
+    },
+    "node_modules/css-select": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/css-select/-/css-select-5.2.2.tgz",
+      "integrity": "sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "boolbase": "^1.0.0",
+        "css-what": "^6.1.0",
+        "domhandler": "^5.0.2",
+        "domutils": "^3.0.1",
+        "nth-check": "^2.0.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/fb55"
+      }
+    },
+    "node_modules/css-what": {
+      "version": "6.2.2",
+      "resolved": "https://registry.npmjs.org/css-what/-/css-what-6.2.2.tgz",
+      "integrity": "sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">= 6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/fb55"
+      }
+    },
+    "node_modules/cssom": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.5.0.tgz",
+      "integrity": "sha512-iKuQcq+NdHqlAcwUY0o/HL69XQrUaQdMjmStJ8JFmUaiiQErlhrmuigkg/CU4E2J0IyUKUrMAgl36TvN67MqTw==",
+      "license": "MIT"
+    },
+    "node_modules/dom-serializer": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
+      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.2",
+        "entities": "^4.2.0"
+      },
+      "funding": {
+        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
+      }
+    },
+    "node_modules/domelementtype": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
+      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/domhandler": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
+      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "domelementtype": "^2.3.0"
+      },
+      "engines": {
+        "node": ">= 4"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domhandler?sponsor=1"
+      }
+    },
+    "node_modules/domutils": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
+      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "dom-serializer": "^2.0.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domutils?sponsor=1"
+      }
+    },
+    "node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/html-escaper": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-3.0.3.tgz",
+      "integrity": "sha512-RuMffC89BOWQoY0WKGpIhn5gX3iI54O6nRA0yC124NYVtzjmFWBIiFd8M0x+ZdX0P9R4lADg1mgP8C7PxGOWuQ==",
+      "license": "MIT"
+    },
+    "node_modules/htmlparser2": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-10.1.0.tgz",
+      "integrity": "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ==",
+      "funding": [
+        "https://github.com/fb55/htmlparser2?sponsor=1",
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.2.2",
+        "entities": "^7.0.1"
+      }
+    },
+    "node_modules/htmlparser2/node_modules/entities": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
+      "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/linkedom": {
+      "version": "0.18.12",
+      "resolved": "https://registry.npmjs.org/linkedom/-/linkedom-0.18.12.tgz",
+      "integrity": "sha512-jalJsOwIKuQJSeTvsgzPe9iJzyfVaEJiEXl+25EkKevsULHvMJzpNqwvj1jOESWdmgKDiXObyjOYwlUqG7wo1Q==",
+      "license": "ISC",
+      "dependencies": {
+        "css-select": "^5.1.0",
+        "cssom": "^0.5.0",
+        "html-escaper": "^3.0.3",
+        "htmlparser2": "^10.0.0",
+        "uhyphen": "^0.2.0"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "peerDependencies": {
+        "canvas": ">= 2"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/nth-check": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-2.1.1.tgz",
+      "integrity": "sha512-lqjrjmaOoAnWfMmBPL+XNnynZh2+swxiX3WUE0s4yEHI6m+AwrK2UZOimIRl3X/4QctVqS8AiZjFqyOGrMXb/w==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "boolbase": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/nth-check?sponsor=1"
+      }
+    },
+    "node_modules/typescript": {
+      "version": "5.9.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.9.3.tgz",
+      "integrity": "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/uhyphen": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/uhyphen/-/uhyphen-0.2.0.tgz",
+      "integrity": "sha512-qz3o9CHXmJJPGBdqzab7qAYuW8kQGKNEuoHFYrBwV6hWIMcpAmxDLXojcHfFr9US1Pe6zUswEIJIbLI610fuqA==",
+      "license": "ISC"
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    }
+  }
+}

package/container/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "hybridclaw-agent",
+  "version": "0.1.5",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "lint": "tsc --noEmit --noUnusedLocals --noUnusedParameters"
+  },
+  "dependencies": {
+    "@mozilla/readability": "^0.6.0",
+    "linkedom": "^0.18.12"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.0"
+  }
+}

package/container/src/hybridai-client.ts

@@ -0,0 +1,38 @@
+import type { ChatCompletionResponse, ChatMessage, ToolDefinition } from './types.js';
+
+export async function callHybridAI(
+  baseUrl: string,
+  apiKey: string,
+  model: string,
+  chatbotId: string,
+  enableRag: boolean,
+  messages: ChatMessage[],
+  tools: ToolDefinition[],
+): Promise<ChatCompletionResponse> {
+  const url = `${baseUrl}/v1/chat/completions`;
+
+  const body: Record<string, unknown> = {
+    model,
+    chatbot_id: chatbotId,
+    messages,
+    tools,
+    tool_choice: 'auto',
+    enable_rag: enableRag,
+  };
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`HybridAI API error ${response.status}: ${text}`);
+  }
+
+  return (await response.json()) as ChatCompletionResponse;
+}

package/container/src/index.ts

@@ -0,0 +1,198 @@
+import { callHybridAI } from './hybridai-client.js';
+import { waitForInput, writeOutput } from './ipc.js';
+import { executeTool, getPendingSideEffects, resetSideEffects, setScheduledTasks, setSessionContext, TOOL_DEFINITIONS } from './tools.js';
+import type { ChatMessage, ContainerInput, ContainerOutput, ToolDefinition, ToolExecution } from './types.js';
+
+const MAX_ITERATIONS = 20;
+const IDLE_TIMEOUT_MS = parseInt(process.env.CONTAINER_IDLE_TIMEOUT || '300000', 10); // 5 min
+
+/** API key received once via stdin, held in memory for the container lifetime. */
+let storedApiKey = '';
+
+/**
+ * Read a single line from stdin (the initial request JSON containing secrets).
+ * Resolves on the first newline — does not consume the entire stream, so docker -i
+ * keeps the container alive after the host stops writing.
+ */
+function readStdinLine(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let buffer = '';
+    const onData = (chunk: Buffer) => {
+      buffer += chunk.toString('utf-8');
+      const nl = buffer.indexOf('\n');
+      if (nl !== -1) {
+        process.stdin.removeListener('data', onData);
+        process.stdin.removeListener('error', onError);
+        process.stdin.pause();
+        resolve(buffer.slice(0, nl));
+      }
+    };
+    const onError = (err: Error) => {
+      process.stdin.removeListener('data', onData);
+      reject(err);
+    };
+    process.stdin.on('data', onData);
+    process.stdin.on('error', onError);
+    process.stdin.resume();
+  });
+}
+
+/**
+ * Process a single request: call API, run tool loop, write output.
+ */
+async function processRequest(
+  messages: ChatMessage[],
+  apiKey: string,
+  baseUrl: string,
+  model: string,
+  chatbotId: string,
+  enableRag: boolean,
+  tools: ToolDefinition[],
+): Promise<ContainerOutput> {
+  const history: ChatMessage[] = [...messages];
+  const toolsUsed: string[] = [];
+  const toolExecutions: ToolExecution[] = [];
+  let iterations = 0;
+
+  while (iterations < MAX_ITERATIONS) {
+    iterations++;
+
+    let response;
+    try {
+      response = await callHybridAI(baseUrl, apiKey, model, chatbotId, enableRag, history, tools);
+    } catch (err) {
+      return { status: 'error', result: null, toolsUsed, toolExecutions, error: `API error: ${err instanceof Error ? err.message : String(err)}` };
+    }
+
+    const choice = response.choices[0];
+    if (!choice) {
+      return { status: 'error', result: null, toolsUsed, toolExecutions, error: 'No response from API' };
+    }
+
+    const assistantMessage: ChatMessage = {
+      role: 'assistant',
+      content: choice.message.content,
+    };
+
+    if (choice.message.tool_calls && choice.message.tool_calls.length > 0) {
+      assistantMessage.tool_calls = choice.message.tool_calls;
+    }
+
+    history.push(assistantMessage);
+
+    const toolCalls = choice.message.tool_calls || [];
+    if (toolCalls.length === 0) {
+      return { status: 'success', result: choice.message.content, toolsUsed: [...new Set(toolsUsed)], toolExecutions };
+    }
+
+    for (const call of toolCalls) {
+      const toolName = call.function.name;
+      toolsUsed.push(toolName);
+      console.error(`[tool] ${toolName}: ${call.function.arguments.slice(0, 100)}`);
+      const toolStart = Date.now();
+      const result = await executeTool(toolName, call.function.arguments);
+      const toolDuration = Date.now() - toolStart;
+      console.error(`[tool] ${toolName} result (${toolDuration}ms): ${result.slice(0, 100)}`);
+      toolExecutions.push({
+        name: toolName,
+        arguments: call.function.arguments,
+        result,
+        durationMs: toolDuration,
+      });
+      history.push({ role: 'tool', content: result, tool_call_id: call.id });
+
+      // Bail on fatal filesystem/system errors — retrying won't help
+      if (/EROFS|EPERM|EACCES|read-only file system/i.test(result)) {
+        return { status: 'error', result: null, toolsUsed, toolExecutions, error: result };
+      }
+    }
+  }
+
+  const lastAssistant = history.filter((m) => m.role === 'assistant').pop();
+  return { status: 'success', result: lastAssistant?.content || 'Max tool iterations reached.', toolsUsed: [...new Set(toolsUsed)], toolExecutions };
+}
+
+/**
+ * Main loop: read first request from stdin (with secrets), then poll IPC for follow-ups.
+ */
+function resolveTools(input: ContainerInput): ToolDefinition[] {
+  const tools = input.allowedTools
+    ? TOOL_DEFINITIONS.filter((t) => input.allowedTools!.includes(t.function.name))
+    : [...TOOL_DEFINITIONS];
+  // Sort alphabetically for deterministic system-prompt ordering (KV cache stability)
+  tools.sort((a, b) => a.function.name.localeCompare(b.function.name));
+  return tools;
+}
+
+async function main(): Promise<void> {
+  console.error(`[hybridclaw-agent] started, idle timeout ${IDLE_TIMEOUT_MS}ms`);
+
+  // First request arrives via stdin (contains apiKey — never written to disk)
+  const stdinData = await readStdinLine();
+  const firstInput: ContainerInput = JSON.parse(stdinData);
+  storedApiKey = firstInput.apiKey;
+
+  console.error(`[hybridclaw-agent] processing first request (${firstInput.messages.length} messages)`);
+
+  resetSideEffects();
+  setScheduledTasks(firstInput.scheduledTasks);
+  setSessionContext(firstInput.sessionId);
+
+  const firstOutput = await processRequest(
+    firstInput.messages,
+    storedApiKey,
+    firstInput.baseUrl,
+    firstInput.model,
+    firstInput.chatbotId,
+    firstInput.enableRag,
+    resolveTools(firstInput),
+  );
+
+  firstOutput.sideEffects = getPendingSideEffects();
+  writeOutput(firstOutput);
+  console.error(`[hybridclaw-agent] first request complete: ${firstOutput.status}`);
+
+  // Subsequent requests come via IPC file polling
+  while (true) {
+    const input = await waitForInput(IDLE_TIMEOUT_MS);
+
+    if (!input) {
+      console.error('[hybridclaw-agent] idle timeout, exiting');
+      process.exit(0);
+    }
+
+    // Use stored apiKey — IPC file no longer contains it
+    const apiKey = input.apiKey || storedApiKey;
+
+    console.error(`[hybridclaw-agent] processing request (${input.messages.length} messages)`);
+
+    resetSideEffects();
+    setScheduledTasks(input.scheduledTasks);
+    setSessionContext(input.sessionId);
+
+    const output = await processRequest(
+      input.messages,
+      apiKey,
+      input.baseUrl,
+      input.model,
+      input.chatbotId,
+      input.enableRag,
+      resolveTools(input),
+    );
+
+    output.sideEffects = getPendingSideEffects();
+    writeOutput(output);
+    console.error(`[hybridclaw-agent] request complete: ${output.status}`);
+  }
+}
+
+main().catch((err) => {
+  console.error('Container agent fatal error:', err);
+  writeOutput({
+    status: 'error',
+    result: null,
+    toolsUsed: [],
+    error: `Unhandled error: ${err instanceof Error ? err.message : String(err)}`,
+  });
+  process.exit(1);
+});

package/container/src/ipc.ts

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import path from 'path';
+
+import type { ContainerInput, ContainerOutput } from './types.js';
+
+const IPC_DIR = '/ipc';
+const INPUT_PATH = path.join(IPC_DIR, 'input.json');
+const OUTPUT_PATH = path.join(IPC_DIR, 'output.json');
+
+/**
+ * Poll for input.json. Returns null if idle timeout expires.
+ */
+export async function waitForInput(idleTimeoutMs: number): Promise<ContainerInput | null> {
+  const pollInterval = 200;
+  const deadline = Date.now() + idleTimeoutMs;
+
+  while (Date.now() < deadline) {
+    if (fs.existsSync(INPUT_PATH)) {
+      try {
+        const raw = fs.readFileSync(INPUT_PATH, 'utf-8');
+        const input = JSON.parse(raw) as ContainerInput;
+        // Remove input file to signal we've consumed it
+        fs.unlinkSync(INPUT_PATH);
+        return input;
+      } catch {
+        // Partially written, retry
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+  }
+
+  return null; // Idle timeout
+}
+
+export function writeOutput(output: ContainerOutput): void {
+  fs.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
+}