@hybridaione/hybridclaw 0.1.5

package/container/src/types.ts

@@ -0,0 +1,74 @@
+export interface ChatMessage {
+  role: 'system' | 'user' | 'assistant' | 'tool';
+  content: string | null;
+  tool_calls?: ToolCall[];
+  tool_call_id?: string;
+}
+
+export interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface ChatCompletionResponse {
+  id: string;
+  choices: Array<{
+    message: {
+      role: string;
+      content: string | null;
+      tool_calls?: ToolCall[];
+    };
+    finish_reason: string;
+  }>;
+  model: string;
+}
+
+export interface ToolDefinition {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: {
+      type: 'object';
+      properties: Record<string, { type: string; description: string }>;
+      required: string[];
+    };
+  };
+}
+
+export interface ContainerInput {
+  sessionId: string;
+  messages: ChatMessage[];
+  chatbotId: string;
+  enableRag: boolean;
+  apiKey: string;
+  baseUrl: string;
+  model: string;
+  channelId: string;
+  scheduledTasks?: { id: number; cronExpr: string; runAt: string | null; everyMs: number | null; prompt: string; enabled: number; lastRun: string | null; createdAt: string }[];
+  allowedTools?: string[];
+}
+
+export interface ToolExecution {
+  name: string;
+  arguments: string;
+  result: string;
+  durationMs: number;
+}
+
+export interface ContainerOutput {
+  status: 'success' | 'error';
+  result: string | null;
+  toolsUsed: string[];
+  toolExecutions?: ToolExecution[];
+  error?: string;
+  sideEffects?: { schedules?: ScheduleSideEffect[] };
+}
+
+export type ScheduleSideEffect =
+  | { action: 'add'; cronExpr?: string; runAt?: string; everyMs?: number; prompt: string }
+  | { action: 'remove'; taskId: number };

package/container/src/web-fetch.ts

@@ -0,0 +1,389 @@
+/**
+ * web-fetch tool — fetch a URL and extract readable content.
+ *
+ * Ported from OpenClaw's web-fetch but stripped down:
+ * - No Firecrawl fallback
+ * - No SSRF guard framework (container is sandboxed, basic URL validation suffices)
+ * - No external-content wrapping
+ * - No config system — sensible hardcoded defaults
+ */
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const DEFAULT_MAX_CHARS = 50_000;
+const MAX_RESPONSE_BYTES = 2_000_000;
+const MAX_REDIRECTS = 5;
+const TIMEOUT_MS = 30_000;
+const CACHE_TTL_MS = 15 * 60_000; // 15 min
+const CACHE_MAX_ENTRIES = 100;
+const READABILITY_MAX_HTML_CHARS = 1_000_000;
+const USER_AGENT =
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7_2) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36';
+
+// ---------------------------------------------------------------------------
+// Cache
+// ---------------------------------------------------------------------------
+
+interface CacheEntry {
+  value: WebFetchResult;
+  expiresAt: number;
+}
+
+const cache = new Map<string, CacheEntry>();
+
+function readCache(key: string): WebFetchResult | null {
+  const entry = cache.get(key);
+  if (!entry) return null;
+  if (Date.now() > entry.expiresAt) {
+    cache.delete(key);
+    return null;
+  }
+  return entry.value;
+}
+
+function writeCache(key: string, value: WebFetchResult): void {
+  if (cache.size >= CACHE_MAX_ENTRIES) {
+    const oldest = cache.keys().next();
+    if (!oldest.done) cache.delete(oldest.value);
+  }
+  cache.set(key, { value, expiresAt: Date.now() + CACHE_TTL_MS });
+}
+
+// ---------------------------------------------------------------------------
+// HTML helpers (inlined from OpenClaw's web-fetch-utils)
+// ---------------------------------------------------------------------------
+
+function decodeEntities(value: string): string {
+  return value
+    .replace(/&nbsp;/gi, ' ')
+    .replace(/&amp;/gi, '&')
+    .replace(/&quot;/gi, '"')
+    .replace(/&#39;/gi, "'")
+    .replace(/&lt;/gi, '<')
+    .replace(/&gt;/gi, '>')
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+    .replace(/&#(\d+);/gi, (_, dec) => String.fromCharCode(parseInt(dec, 10)));
+}
+
+function stripTags(value: string): string {
+  return decodeEntities(value.replace(/<[^>]+>/g, ''));
+}
+
+function normalizeWhitespace(value: string): string {
+  return value
+    .replace(/\r/g, '')
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .replace(/[ \t]{2,}/g, ' ')
+    .trim();
+}
+
+function htmlToMarkdown(html: string): { text: string; title?: string } {
+  const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+  const title = titleMatch ? normalizeWhitespace(stripTags(titleMatch[1])) : undefined;
+
+  let text = html
+    .replace(/<script[\s\S]*?<\/script>/gi, '')
+    .replace(/<style[\s\S]*?<\/style>/gi, '')
+    .replace(/<noscript[\s\S]*?<\/noscript>/gi, '');
+
+  // Links
+  text = text.replace(/<a\s+[^>]*href=["']([^"']+)["'][^>]*>([\s\S]*?)<\/a>/gi, (_, href, body) => {
+    const label = normalizeWhitespace(stripTags(body));
+    return label ? `[${label}](${href})` : href;
+  });
+
+  // Headings
+  text = text.replace(/<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi, (_, level, body) => {
+    const prefix = '#'.repeat(Math.max(1, Math.min(6, parseInt(level, 10))));
+    return `\n${prefix} ${normalizeWhitespace(stripTags(body))}\n`;
+  });
+
+  // List items
+  text = text.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, (_, body) => {
+    const label = normalizeWhitespace(stripTags(body));
+    return label ? `\n- ${label}` : '';
+  });
+
+  // Block breaks
+  text = text
+    .replace(/<(br|hr)\s*\/?>/gi, '\n')
+    .replace(/<\/(p|div|section|article|header|footer|table|tr|ul|ol)>/gi, '\n');
+
+  text = stripTags(text);
+  text = normalizeWhitespace(text);
+  return { text, title };
+}
+
+function markdownToText(markdown: string): string {
+  let text = markdown;
+  text = text.replace(/!\[[^\]]*]\([^)]+\)/g, '');
+  text = text.replace(/\[([^\]]+)]\([^)]+\)/g, '$1');
+  text = text.replace(/```[\s\S]*?```/g, (block) =>
+    block.replace(/```[^\n]*\n?/g, '').replace(/```/g, ''),
+  );
+  text = text.replace(/`([^`]+)`/g, '$1');
+  text = text.replace(/^#{1,6}\s+/gm, '');
+  text = text.replace(/^\s*[-*+]\s+/gm, '');
+  text = text.replace(/^\s*\d+\.\s+/gm, '');
+  return normalizeWhitespace(text);
+}
+
+// ---------------------------------------------------------------------------
+// Readability extraction (lazy-loaded)
+// ---------------------------------------------------------------------------
+
+let readabilityDeps: Promise<{
+  Readability: typeof import('@mozilla/readability').Readability;
+  parseHTML: typeof import('linkedom').parseHTML;
+}> | undefined;
+
+function loadReadabilityDeps() {
+  if (!readabilityDeps) {
+    readabilityDeps = Promise.all([
+      import('@mozilla/readability'),
+      import('linkedom'),
+    ]).then(([r, l]) => ({ Readability: r.Readability, parseHTML: l.parseHTML }));
+  }
+  return readabilityDeps;
+}
+
+async function extractReadableContent(
+  html: string,
+  url: string,
+  extractMode: 'markdown' | 'text',
+): Promise<{ text: string; title?: string }> {
+  // Fallback: simple regex-based conversion
+  const fallback = (): { text: string; title?: string } => {
+    const rendered = htmlToMarkdown(html);
+    if (extractMode === 'text') {
+      return { text: markdownToText(rendered.text), title: rendered.title };
+    }
+    return rendered;
+  };
+
+  if (html.length > READABILITY_MAX_HTML_CHARS) {
+    return fallback();
+  }
+
+  try {
+    const { Readability, parseHTML } = await loadReadabilityDeps();
+    const { document } = parseHTML(html);
+    try {
+      (document as { baseURI?: string }).baseURI = url;
+    } catch { /* best-effort */ }
+
+    const reader = new Readability(document, { charThreshold: 0 });
+    const parsed = reader.parse();
+    if (!parsed?.content) return fallback();
+
+    const title = parsed.title || undefined;
+    if (extractMode === 'text') {
+      const text = normalizeWhitespace(parsed.textContent ?? '');
+      return text ? { text, title } : fallback();
+    }
+    const rendered = htmlToMarkdown(parsed.content);
+    return { text: rendered.text, title: title ?? rendered.title };
+  } catch {
+    return fallback();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Streaming response reader with size limit
+// ---------------------------------------------------------------------------
+
+async function readResponseText(
+  res: Response,
+  maxBytes: number,
+): Promise<{ text: string; truncated: boolean }> {
+  const body = res.body;
+  if (body && typeof body === 'object' && 'getReader' in body) {
+    const reader = (body as ReadableStream<Uint8Array>).getReader();
+    const decoder = new TextDecoder();
+    let bytesRead = 0;
+    let truncated = false;
+    const parts: string[] = [];
+
+    try {
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        if (!value || value.byteLength === 0) continue;
+
+        let chunk = value;
+        if (bytesRead + chunk.byteLength > maxBytes) {
+          const remaining = Math.max(0, maxBytes - bytesRead);
+          if (remaining <= 0) { truncated = true; break; }
+          chunk = chunk.subarray(0, remaining);
+          truncated = true;
+        }
+
+        bytesRead += chunk.byteLength;
+        parts.push(decoder.decode(chunk, { stream: true }));
+        if (truncated || bytesRead >= maxBytes) { truncated = true; break; }
+      }
+    } catch { /* return what we have */ } finally {
+      if (truncated) {
+        try { await reader.cancel(); } catch { /* ignore */ }
+      }
+    }
+
+    parts.push(decoder.decode());
+    return { text: parts.join(''), truncated };
+  }
+
+  const text = await res.text();
+  return { text, truncated: false };
+}
+
+// ---------------------------------------------------------------------------
+// Manual redirect following (to track finalUrl)
+// ---------------------------------------------------------------------------
+
+async function fetchWithRedirects(
+  url: string,
+  maxRedirects: number,
+  signal: AbortSignal,
+): Promise<{ response: Response; finalUrl: string }> {
+  let currentUrl = url;
+  for (let i = 0; i <= maxRedirects; i++) {
+    const res = await fetch(currentUrl, {
+      redirect: 'manual',
+      headers: {
+        Accept: 'text/markdown, text/html;q=0.9, */*;q=0.1',
+        'User-Agent': USER_AGENT,
+        'Accept-Language': 'en-US,en;q=0.9',
+      },
+      signal,
+    });
+
+    const location = res.headers.get('location');
+    if (location && res.status >= 300 && res.status < 400) {
+      // Resolve relative redirects
+      currentUrl = new URL(location, currentUrl).toString();
+      continue;
+    }
+    return { response: res, finalUrl: currentUrl };
+  }
+  throw new Error(`Too many redirects (max ${maxRedirects})`);
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+export interface WebFetchResult {
+  url: string;
+  finalUrl: string;
+  status: number;
+  contentType?: string;
+  title?: string;
+  extractMode: string;
+  extractor: string;
+  truncated: boolean;
+  length: number;
+  fetchedAt: string;
+  tookMs: number;
+  text: string;
+  cached?: boolean;
+  warning?: string;
+}
+
+export async function webFetch(params: {
+  url: string;
+  extractMode?: 'markdown' | 'text';
+  maxChars?: number;
+}): Promise<WebFetchResult> {
+  const extractMode = params.extractMode ?? 'markdown';
+  const maxChars = Math.max(100, Math.min(params.maxChars ?? DEFAULT_MAX_CHARS, DEFAULT_MAX_CHARS));
+
+  // Validate URL
+  let parsedUrl: URL;
+  try {
+    parsedUrl = new URL(params.url);
+  } catch {
+    throw new Error('Invalid URL: must be http or https');
+  }
+  if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+    throw new Error('Invalid URL: must be http or https');
+  }
+
+  // Check cache
+  const cacheKey = `fetch:${params.url}:${extractMode}:${maxChars}`.toLowerCase();
+  const cached = readCache(cacheKey);
+  if (cached) return { ...cached, cached: true };
+
+  const start = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+
+  try {
+    const { response: res, finalUrl } = await fetchWithRedirects(
+      params.url,
+      MAX_REDIRECTS,
+      controller.signal,
+    );
+
+    if (!res.ok) {
+      throw new Error(`Web fetch failed (${res.status}): ${res.statusText}`);
+    }
+
+    const contentType = res.headers.get('content-type') ?? 'application/octet-stream';
+    const normalizedContentType = contentType.split(';')[0]?.trim() || 'application/octet-stream';
+    const bodyResult = await readResponseText(res, MAX_RESPONSE_BYTES);
+    const body = bodyResult.text;
+
+    let title: string | undefined;
+    let extractor = 'raw';
+    let text = body;
+
+    if (contentType.includes('text/markdown')) {
+      extractor = 'cf-markdown';
+      if (extractMode === 'text') text = markdownToText(body);
+    } else if (contentType.includes('text/html')) {
+      const readable = await extractReadableContent(body, finalUrl, extractMode);
+      text = readable.text;
+      title = readable.title;
+      extractor = 'readability';
+    } else if (contentType.includes('application/json')) {
+      try {
+        text = JSON.stringify(JSON.parse(body), null, 2);
+        extractor = 'json';
+      } catch {
+        extractor = 'raw';
+      }
+    }
+
+    // Truncate
+    const truncated = text.length > maxChars;
+    if (truncated) text = text.slice(0, maxChars);
+
+    const warning = bodyResult.truncated
+      ? `Response body truncated after ${MAX_RESPONSE_BYTES} bytes.`
+      : undefined;
+
+    const result: WebFetchResult = {
+      url: params.url,
+      finalUrl,
+      status: res.status,
+      contentType: normalizedContentType,
+      title,
+      extractMode,
+      extractor,
+      truncated: truncated || bodyResult.truncated,
+      length: text.length,
+      fetchedAt: new Date().toISOString(),
+      tookMs: Date.now() - start,
+      text,
+      warning,
+    };
+
+    writeCache(cacheKey, result);
+    return result;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/container/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/agent.d.ts

@@ -0,0 +1,3 @@
+import type { ChatMessage, ContainerOutput, ScheduledTask, ToolProgressEvent } from './types.js';
+export declare function runAgent(sessionId: string, messages: ChatMessage[], chatbotId: string, enableRag: boolean, model: string, agentId: string, channelId: string, scheduledTasks?: ScheduledTask[], allowedTools?: string[], onToolProgress?: (event: ToolProgressEvent) => void, abortSignal?: AbortSignal): Promise<ContainerOutput>;
+//# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAWjG,wBAAsB,QAAQ,CAC5B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,WAAW,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,OAAO,EAClB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,cAAc,CAAC,EAAE,aAAa,EAAE,EAChC,YAAY,CAAC,EAAE,MAAM,EAAE,EACvB,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,EACnD,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,eAAe,CAAC,CAG1B"}

package/dist/agent.js

@@ -0,0 +1,21 @@
+/**
+ * Agent — always runs through a container for consistent sandboxing.
+ */
+import fs from 'fs';
+import path from 'path';
+import { DATA_DIR } from './config.js';
+import { runContainer } from './container-runner.js';
+/** Write full prompt context to data/last_prompt.jsonl for debugging (Pi-Mono style). */
+function dumpPrompt(sessionId, messages, model, chatbotId) {
+    try {
+        const entry = { ts: new Date().toISOString(), sessionId, model, chatbotId, messages };
+        const filePath = path.join(DATA_DIR, 'last_prompt.jsonl');
+        fs.writeFileSync(filePath, JSON.stringify(entry) + '\n');
+    }
+    catch { /* best-effort */ }
+}
+export async function runAgent(sessionId, messages, chatbotId, enableRag, model, agentId, channelId, scheduledTasks, allowedTools, onToolProgress, abortSignal) {
+    dumpPrompt(sessionId, messages, model, chatbotId);
+    return runContainer(sessionId, messages, chatbotId, enableRag, model, agentId, channelId, scheduledTasks, allowedTools, onToolProgress, abortSignal);
+}
+//# sourceMappingURL=agent.js.map

package/dist/agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.js","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,MAAM,IAAI,CAAC;AACpB,OAAO,IAAI,MAAM,MAAM,CAAC;AAExB,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGrD,yFAAyF;AACzF,SAAS,UAAU,CAAC,SAAiB,EAAE,QAAuB,EAAE,KAAa,EAAE,SAAiB;IAC9F,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,EAAE,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC;QACtF,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,mBAAmB,CAAC,CAAC;QAC1D,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,CAAC;IAC3D,CAAC;IAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC,CAAC;AAC/B,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC5B,SAAiB,EACjB,QAAuB,EACvB,SAAiB,EACjB,SAAkB,EAClB,KAAa,EACb,OAAe,EACf,SAAiB,EACjB,cAAgC,EAChC,YAAuB,EACvB,cAAmD,EACnD,WAAyB;IAEzB,UAAU,CAAC,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;IAClD,OAAO,YAAY,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,WAAW,CAAC,CAAC;AACvJ,CAAC"}

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cli.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { ensureHybridAICredentials } from './onboarding.js';
+async function main() {
+    const command = process.argv[2];
+    switch (command) {
+        case 'gateway':
+            await ensureHybridAICredentials({ commandName: 'hybridclaw gateway' });
+            await import('./gateway.js');
+            break;
+        case 'tui':
+            await ensureHybridAICredentials({ commandName: 'hybridclaw tui' });
+            await import('./tui.js');
+            break;
+        case 'onboarding':
+            await ensureHybridAICredentials({ force: true, commandName: 'hybridclaw onboarding' });
+            break;
+        default:
+            console.log(`Usage: hybridclaw <command>
+
+Commands:
+  gateway    Start core runtime (web/API/scheduler/heartbeat/optional Discord)
+  tui        Start terminal adapter (requires running gateway)
+  onboarding Run HybridAI account/API key onboarding`);
+            process.exit(command ? 1 : 0);
+    }
+}
+main().catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(`hybridclaw error: ${message}`);
+    process.exit(1);
+});
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,yBAAyB,EAAE,MAAM,iBAAiB,CAAC;AAE5D,KAAK,UAAU,IAAI;IACjB,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAEhC,QAAQ,OAAO,EAAE,CAAC;QAChB,KAAK,SAAS;YACZ,MAAM,yBAAyB,CAAC,EAAE,WAAW,EAAE,oBAAoB,EAAE,CAAC,CAAC;YACvE,MAAM,MAAM,CAAC,cAAc,CAAC,CAAC;YAC7B,MAAM;QACR,KAAK,KAAK;YACR,MAAM,yBAAyB,CAAC,EAAE,WAAW,EAAE,gBAAgB,EAAE,CAAC,CAAC;YACnE,MAAM,MAAM,CAAC,UAAU,CAAC,CAAC;YACzB,MAAM;QACR,KAAK,YAAY;YACf,MAAM,yBAAyB,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,uBAAuB,EAAE,CAAC,CAAC;YACvF,MAAM;QACR;YACE,OAAO,CAAC,GAAG,CAAC;;;;;qDAKmC,CAAC,CAAC;YACjD,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAClC,CAAC;AACH,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACnB,MAAM,OAAO,GAAG,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACjE,OAAO,CAAC,KAAK,CAAC,qBAAqB,OAAO,EAAE,CAAC,CAAC;IAC9C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/config.d.ts

@@ -0,0 +1,38 @@
+import { onRuntimeConfigChange, type RuntimeConfig } from './runtime-config.js';
+export declare const APP_VERSION: string;
+export declare const DISCORD_TOKEN: string;
+export declare const HYBRIDAI_API_KEY: string;
+export declare let DISCORD_PREFIX: string;
+export declare let HYBRIDAI_BASE_URL: string;
+export declare let HYBRIDAI_MODEL: string;
+export declare let HYBRIDAI_CHATBOT_ID: string;
+export declare let HYBRIDAI_ENABLE_RAG: boolean;
+export declare let HYBRIDAI_MODELS: string[];
+export declare let CONTAINER_IMAGE: string;
+export declare let CONTAINER_MEMORY: string;
+export declare let CONTAINER_CPUS: string;
+export declare let CONTAINER_TIMEOUT: number;
+export declare const MOUNT_ALLOWLIST_PATH: string;
+export declare let ADDITIONAL_MOUNTS: string;
+export declare let CONTAINER_MAX_OUTPUT_SIZE: number;
+export declare let MAX_CONCURRENT_CONTAINERS: number;
+export declare let HEARTBEAT_ENABLED: boolean;
+export declare let HEARTBEAT_INTERVAL: number;
+export declare let HEARTBEAT_CHANNEL: string;
+export declare let HEALTH_HOST: string;
+export declare let HEALTH_PORT: number;
+export declare let WEB_API_TOKEN: string;
+export declare let GATEWAY_BASE_URL: string;
+export declare let GATEWAY_API_TOKEN: string;
+export declare let DB_PATH: string;
+export declare let DATA_DIR: string;
+export declare let SESSION_COMPACTION_ENABLED: boolean;
+export declare let SESSION_COMPACTION_THRESHOLD: number;
+export declare let SESSION_COMPACTION_KEEP_RECENT: number;
+export declare let SESSION_COMPACTION_SUMMARY_MAX_CHARS: number;
+export declare let PRE_COMPACTION_MEMORY_FLUSH_ENABLED: boolean;
+export declare let PRE_COMPACTION_MEMORY_FLUSH_MAX_MESSAGES: number;
+export declare let PRE_COMPACTION_MEMORY_FLUSH_MAX_CHARS: number;
+export { onRuntimeConfigChange as onConfigChange };
+export declare function getConfigSnapshot(): RuntimeConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAKA,OAAO,EAGL,qBAAqB,EACrB,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AA6B7B,eAAO,MAAM,WAAW,QAAsB,CAAC;AAG/C,eAAO,MAAM,aAAa,QAAkC,CAAC;AAC7D,eAAO,MAAM,gBAAgB,QAA+B,CAAC;AAG7D,eAAO,IAAI,cAAc,QAAU,CAAC;AAEpC,eAAO,IAAI,iBAAiB,QAAyB,CAAC;AACtD,eAAO,IAAI,cAAc,QAAe,CAAC;AACzC,eAAO,IAAI,mBAAmB,QAAK,CAAC;AACpC,eAAO,IAAI,mBAAmB,SAAO,CAAC;AACtC,eAAO,IAAI,eAAe,EAAE,MAAM,EAA0C,CAAC;AAE7E,eAAO,IAAI,eAAe,QAAqB,CAAC;AAChD,eAAO,IAAI,gBAAgB,QAAS,CAAC;AACrC,eAAO,IAAI,cAAc,QAAM,CAAC;AAChC,eAAO,IAAI,iBAAiB,QAAS,CAAC;AAEtC,eAAO,MAAM,oBAAoB,QAEhC,CAAC;AACF,eAAO,IAAI,iBAAiB,QAAK,CAAC;AAElC,eAAO,IAAI,yBAAyB,QAAa,CAAC;AAClD,eAAO,IAAI,yBAAyB,QAAI,CAAC;AAEzC,eAAO,IAAI,iBAAiB,SAAO,CAAC;AACpC,eAAO,IAAI,kBAAkB,QAAY,CAAC;AAC1C,eAAO,IAAI,iBAAiB,QAAK,CAAC;AAElC,eAAO,IAAI,WAAW,QAAc,CAAC;AACrC,eAAO,IAAI,WAAW,QAAO,CAAC;AAC9B,eAAO,IAAI,aAAa,QAAK,CAAC;AAC9B,eAAO,IAAI,gBAAgB,QAA0B,CAAC;AACtD,eAAO,IAAI,iBAAiB,QAAK,CAAC;AAClC,eAAO,IAAI,OAAO,QAAuB,CAAC;AAC1C,eAAO,IAAI,QAAQ,QAAwB,CAAC;AAE5C,eAAO,IAAI,0BAA0B,SAAO,CAAC;AAC7C,eAAO,IAAI,4BAA4B,QAAM,CAAC;AAC9C,eAAO,IAAI,8BAA8B,QAAK,CAAC;AAC/C,eAAO,IAAI,oCAAoC,QAAQ,CAAC;AACxD,eAAO,IAAI,mCAAmC,SAAO,CAAC;AACtD,eAAO,IAAI,wCAAwC,QAAK,CAAC;AACzD,eAAO,IAAI,qCAAqC,QAAS,CAAC;AAgD1D,OAAO,EAAE,qBAAqB,IAAI,cAAc,EAAE,CAAC;AACnD,wBAAgB,iBAAiB,IAAI,aAAa,CAEjD"}