arisa 2.3.15 → 2.3.16

package/README.md

@@ -14,11 +14,9 @@ Arisa can execute actions with operational control over the system where it runs
 
 ```bash
 curl -fsSL https://bun.sh/install | bash  # Install Bun https://bun.sh
-
-bun add -g @anthropic-ai/claude-code      # Install Claude CLI (both or one is required)
-bun add -g @openai/codex                  # Install Codex CLI (both or one is required)
-
 bun add -g arisa                          # Install Arisa CLI
+
+# @anthropic-ai/claude-code and @openai/codex (auto-installed if missing)
 ```
 
 ## Commands

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "arisa",
-  "version": "2.3.15",
+  "version": "2.3.16",
   "description": "Arisa - dynamic agent runtime with daemon/core architecture that evolves through user interaction",
   "preferGlobal": true,
   "bin": {
     "arisa": "./bin/arisa.js"
   },
   "files": [
-    "bin",
-    "src",
-    "scripts",
+    "tinyclaw",
+    "clawbot",
+    "moltbot",
+    "openclaw",
+    "agent",
+    "telegram",
+    "jarvis",
     "CLAUDE.md",
     "SOUL.md",
-    "README.md",
-    "tsconfig.json"
+    "clasen"
   ],
   "engines": {
     "node": ">=18",

package/scripts/test-secrets.ts

@@ -1,22 +0,0 @@
-#!/usr/bin/env bun
-/**
- * Test encrypted secrets loading
- */
-
-import { secrets } from "../src/shared/secrets";
-
-async function main() {
-  console.log("🔐 Testing encrypted secrets...\n");
-
-  const telegram = await secrets.telegram();
-  const openai = await secrets.openai();
-  const elevenlabs = await secrets.elevenlabs();
-
-  console.log("✓ TELEGRAM_BOT_TOKEN:", telegram ? `${telegram.slice(0, 10)}...${telegram.slice(-10)}` : "NOT FOUND");
-  console.log("✓ OPENAI_API_KEY:", openai ? `${openai.slice(0, 10)}...${openai.slice(-10)}` : "NOT FOUND");
-  console.log("✓ ELEVENLABS_API_KEY:", elevenlabs ? `${elevenlabs.slice(0, 10)}...${elevenlabs.slice(-10)}` : "NOT FOUND");
-
-  console.log("\n✅ Secrets loaded successfully from encrypted DB");
-}
-
-main();

package/src/core/attachments.ts

@@ -1,104 +0,0 @@
-/**
- * @module core/attachments
- * @role Persist media attachments so the model can access them later.
- * @responsibilities
- *   - Save base64 attachments to runtime attachments/{chatId}/
- *   - Track metadata in deepbase (collection: "attachments")
- *   - Clean up files older than configured max age
- * @dependencies shared/config, shared/db
- * @effects Disk I/O in runtime attachments dir, deepbase writes
- */
-
-import { mkdirSync, existsSync, unlinkSync, rmdirSync, readdirSync } from "fs";
-import { join, dirname, relative } from "path";
-import { config } from "../shared/config";
-import { createLogger } from "../shared/logger";
-import { addAttachment, getExpiredAttachments, deleteAttachment, cleanupOldMessages } from "../shared/db";
-import type { AttachmentRecord } from "../shared/types";
-
-const log = createLogger("core");
-
-const EXT_MAP: Record<string, string> = {
-  image: "jpg",
-  audio: "ogg",
-  document: "bin",
-};
-
-export async function initAttachments(): Promise<void> {
-  if (!existsSync(config.attachmentsDir)) {
-    mkdirSync(config.attachmentsDir, { recursive: true });
-  }
-  await cleanupOldAttachments();
-  const msgsCleaned = await cleanupOldMessages(config.attachmentMaxAgeDays);
-  if (msgsCleaned > 0) {
-    log.info(`Cleaned up ${msgsCleaned} expired message record(s)`);
-  }
-}
-
-export async function saveAttachment(
-  chatId: string,
-  type: "image" | "audio" | "document",
-  base64: string,
-  filename?: string,
-  mimeType?: string,
-): Promise<string> {
-  const chatDir = join(config.attachmentsDir, chatId);
-  if (!existsSync(chatDir)) {
-    mkdirSync(chatDir, { recursive: true });
-  }
-
-  const ext = filename ? filename.split(".").pop() || EXT_MAP[type] : EXT_MAP[type];
-  const hex = Math.random().toString(16).slice(2, 6);
-  const prefix = type === "image" ? "img" : type === "audio" ? "aud" : "doc";
-  const outName = `${prefix}_${Date.now()}_${hex}.${ext}`;
-  const outPath = join(chatDir, outName);
-
-  const buffer = Buffer.from(base64, "base64");
-  await Bun.write(outPath, buffer);
-
-  let relPath = relative(config.projectDir, outPath).replace(/\\/g, "/");
-  if (relPath.startsWith("..")) {
-    relPath = outPath;
-  }
-
-  const record: AttachmentRecord = {
-    id: `${chatId}_${outName}`,
-    chatId,
-    type,
-    filename: filename || outName,
-    relPath,
-    mimeType,
-    sizeBytes: buffer.length,
-    createdAt: Date.now(),
-  };
-  await addAttachment(record);
-
-  log.info(`Saved ${type} attachment: ${relPath} (${buffer.length} bytes)`);
-  return relPath;
-}
-
-async function cleanupOldAttachments(): Promise<void> {
-  const expired = await getExpiredAttachments(config.attachmentMaxAgeDays);
-  if (expired.length === 0) return;
-
-  let cleaned = 0;
-  for (const record of expired) {
-    const absPath = join(config.projectDir, record.relPath);
-    try {
-      if (existsSync(absPath)) {
-        unlinkSync(absPath);
-      }
-      // Remove empty chat dir
-      const dir = dirname(absPath);
-      if (existsSync(dir) && readdirSync(dir).length === 0) {
-        rmdirSync(dir);
-      }
-    } catch {
-      // File already gone — just clean the record
-    }
-    await deleteAttachment(record.id);
-    cleaned++;
-  }
-
-  log.info(`Cleaned up ${cleaned} expired attachment(s)`);
-}

package/src/core/auth.ts

@@ -1,58 +0,0 @@
-/**
- * @module core/auth
- * @role Gate access to the bot via a one-time token shown in the console.
- * @responsibilities
- *   - Generate and persist an auth token via deepbase (settings.auth_token)
- *   - Track authorized chat IDs via deepbase (authorized collection)
- *   - Validate tokens from new chats
- * @dependencies shared/db
- * @effects deepbase writes, console output
- */
-
-import { createLogger } from "../shared/logger";
-import { getAuthorizedUsers, addAuthorized, getSetting, setSetting } from "../shared/db";
-
-const log = createLogger("auth");
-
-let authToken = "";
-let authorizedChats: Set<string> = new Set();
-
-async function loadToken(): Promise<string> {
-  const existing = await getSetting("auth_token");
-  if (existing) return existing;
-
-  const token = crypto.randomUUID().split("-")[0];
-  await setSetting("auth_token", token);
-  return token;
-}
-
-async function loadAuthorized(): Promise<Set<string>> {
-  try {
-    const users = await getAuthorizedUsers();
-    return new Set(users);
-  } catch (error) {
-    log.error(`Failed to load authorized users: ${error}`);
-    return new Set();
-  }
-}
-
-export async function initAuth() {
-  authToken = await loadToken();
-  authorizedChats = await loadAuthorized();
-  log.info(`Auth token: ${authToken}`);
-  console.log(`\n🔑 Auth token: ${authToken}\n   Send this token to the bot on Telegram to authorize a chat.\n`);
-}
-
-export function isAuthorized(chatId: string): boolean {
-  return authorizedChats.has(chatId);
-}
-
-export async function tryAuthorize(chatId: string, message: string): Promise<boolean> {
-  if (message.trim() === authToken) {
-    authorizedChats.add(chatId);
-    await addAuthorized(chatId);
-    log.info(`Chat ${chatId} authorized`);
-    return true;
-  }
-  return false;
-}

package/src/core/context.ts

@@ -1,30 +0,0 @@
-/**
- * @module core/context
- * @role Manage Claude conversation continuity via the -c flag and reset_flag.
- * @responsibilities
- *   - Check if reset_flag exists (user sent /reset)
- *   - Return whether to use -c (continue) flag
- *   - Clear reset_flag after consuming it
- * @dependencies shared/config
- * @effects Reads/deletes reset_flag from runtime data dir
- * @contract shouldContinue() => boolean
- */
-
-import { existsSync, unlinkSync } from "fs";
-import { config } from "../shared/config";
-import { createLogger } from "../shared/logger";
-
-const log = createLogger("core");
-
-export function shouldContinue(): boolean {
-  if (existsSync(config.resetFlagPath)) {
-    log.info("Reset flag found — starting fresh conversation");
-    try {
-      unlinkSync(config.resetFlagPath);
-    } catch {
-      // Already deleted, race condition
-    }
-    return false;
-  }
-  return true;
-}

package/src/core/file-detector.ts

@@ -1,39 +0,0 @@
-/**
- * @module core/file-detector
- * @role Detect file paths mentioned in Claude responses that exist on disk.
- * @responsibilities
- *   - Scan response text for absolute file paths
- *   - Verify they exist and are sendable (< 50MB, not directories)
- *   - Return list of unique valid file paths
- * @dependencies None
- * @effects Reads file system to check existence/size
- * @contract detectFiles(text) => string[]
- */
-
-import { statSync } from "fs";
-
-const FILE_PATH_REGEX = /(\/[\w./-]+\.\w{1,10})/gm;
-const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB
-
-export function detectFiles(text: string): string[] {
-  const matches = [...text.matchAll(FILE_PATH_REGEX)];
-  const seen = new Set<string>();
-  const files: string[] = [];
-
-  for (const match of matches) {
-    const filePath = match[1];
-    if (seen.has(filePath)) continue;
-    seen.add(filePath);
-
-    try {
-      const stat = statSync(filePath);
-      if (stat.isFile() && stat.size < MAX_FILE_SIZE) {
-        files.push(filePath);
-      }
-    } catch {
-      // File doesn't exist or can't be read
-    }
-  }
-
-  return files;
-}

package/src/core/format.ts

@@ -1,159 +0,0 @@
-/**
- * @module core/format
- * @role Format responses for Telegram (HTML) and chunk long messages.
- * @responsibilities
- *   - Split text into chunks respecting Telegram's 4096 char limit
- *   - Safe HTML sending with plain-text fallback marker
- * @dependencies None
- * @effects None (pure functions)
- * @contract chunkMessage(text) => string[]
- */
-
-const MAX_TELEGRAM_LENGTH = 4096;
-
-function escapeHtml(s: string): string {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-
-/** Decode HTML entities so we don't double-encode them when escapeHtml runs. */
-function unescapeHtml(s: string): string {
-  return s
-    .replace(/&amp;/g, "&")
-    .replace(/&lt;/g, "<")
-    .replace(/&gt;/g, ">")
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'");
-}
-
-function protectTelegramHtmlTags(text: string): { text: string; tags: string[] } {
-  const tags: string[] = [];
-  const tagPattern = /<\/?(?:b|i|u|s|code|pre|blockquote)>|<a\s+href="[^"]+">|<\/a>/gi;
-  const protectedText = text.replace(tagPattern, (tag) => {
-    tags.push(tag);
-    return `\x00HTMLTAG${tags.length - 1}\x00`;
-  });
-  return { text: protectedText, tags };
-}
-
-/**
- * Convert Markdown (from Claude CLI) to Telegram-safe HTML.
- * Telegram supports: <b>, <i>, <code>, <pre>, <a>, <s>, <u>, <blockquote>
- * Must also escape HTML entities in non-tag content.
- */
-export function markdownToTelegramHtml(text: string): string {
-  // Step 0: Decode any pre-escaped HTML entities to avoid double-encoding
-  // (e.g. &lt;code&gt; → <code> so protectTelegramHtmlTags can detect them)
-  text = unescapeHtml(text);
-
-  // Step 1: Extract code blocks and links before escaping to protect them
-  const codeBlocks: string[] = [];
-  const inlineCodes: string[] = [];
-  const links: string[] = [];
-
-  // Preserve already-valid Telegram HTML tags instead of escaping them.
-  const protectedHtml = protectTelegramHtmlTags(text);
-
-  // Protect fenced code blocks: ```lang\n...\n``` or ```...```
-  let result = protectedHtml.text.replace(/```(\w*)\n?([\s\S]*?)```/g, (_match, _lang, code) => {
-    codeBlocks.push(code.trimEnd());
-    return `\x00CODEBLOCK${codeBlocks.length - 1}\x00`;
-  });
-
-  // Protect inline code: `...`
-  result = result.replace(/`([^`\n]+)`/g, (_match, code) => {
-    inlineCodes.push(code);
-    return `\x00INLINE${inlineCodes.length - 1}\x00`;
-  });
-
-  // Protect links: [text](url)
-  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, linkText, url) => {
-    links.push(`<a href="${url}">${escapeHtml(linkText)}</a>`);
-    return `\x00LINK${links.length - 1}\x00`;
-  });
-
-  // Step 2: Now escape HTML entities in the remaining text
-  result = escapeHtml(result);
-
-  // Step 3: Convert markdown patterns to HTML tags
-
-  // Bold+Italic: ***text*** or ___text___
-  result = result.replace(/\*{3}(.+?)\*{3}/g, "<b><i>$1</i></b>");
-  result = result.replace(/_{3}(.+?)_{3}/g, "<b><i>$1</i></b>");
-
-  // Bold: **text** or __text__
-  result = result.replace(/\*{2}(.+?)\*{2}/g, "<b>$1</b>");
-  result = result.replace(/_{2}(.+?)_{2}/g, "<b>$1</b>");
-
-  // Italic: *text* or _text_ (not inside words for underscore)
-  result = result.replace(/(?<!\w)\*([^*\n]+)\*(?!\w)/g, "<i>$1</i>");
-  result = result.replace(/(?<!\w)_([^_\n]+)_(?!\w)/g, "<i>$1</i>");
-
-  // Strikethrough: ~~text~~
-  result = result.replace(/~~(.+?)~~/g, "<s>$1</s>");
-
-  // Step 4: Restore protected elements
-  result = result.replace(/\x00CODEBLOCK(\d+)\x00/g, (_m, i) => `<pre>${escapeHtml(codeBlocks[+i])}</pre>`);
-  result = result.replace(/\x00INLINE(\d+)\x00/g, (_m, i) => `<code>${escapeHtml(inlineCodes[+i])}</code>`);
-  result = result.replace(/\x00LINK(\d+)\x00/g, (_m, i) => links[+i]);
-  result = result.replace(/\x00HTMLTAG(\d+)\x00/g, (_m, i) => protectedHtml.tags[+i]);
-
-  return result;
-}
-
-export function chunkMessage(text: string): string[] {
-  if (text.length <= MAX_TELEGRAM_LENGTH) {
-    return [text];
-  }
-
-  const chunks: string[] = [];
-  let remaining = text;
-
-  // Tags that Telegram supports and we use
-  const tagNames = ["pre", "code", "b", "i", "s", "a"];
-
-  while (remaining.length > 0) {
-    if (remaining.length <= MAX_TELEGRAM_LENGTH) {
-      chunks.push(remaining);
-      break;
-    }
-
-    let splitAt = remaining.lastIndexOf("\n", MAX_TELEGRAM_LENGTH);
-    if (splitAt === -1 || splitAt < MAX_TELEGRAM_LENGTH * 0.5) {
-      splitAt = MAX_TELEGRAM_LENGTH;
-    }
-
-    // Check if splitting here would break an HTML tag
-    let candidate = remaining.substring(0, splitAt);
-
-    // Find unclosed tags in the candidate chunk
-    const openTags: string[] = [];
-    const tagRegex = /<\/?([a-z]+)(?:\s[^>]*)?\/?>/gi;
-    let match: RegExpExecArray | null;
-    while ((match = tagRegex.exec(candidate)) !== null) {
-      const fullTag = match[0];
-      const tagName = match[1].toLowerCase();
-      if (!tagNames.includes(tagName)) continue;
-      if (fullTag.startsWith("</")) {
-        // Closing tag - pop if matching
-        const idx = openTags.lastIndexOf(tagName);
-        if (idx !== -1) openTags.splice(idx, 1);
-      } else if (!fullTag.endsWith("/>")) {
-        openTags.push(tagName);
-      }
-    }
-
-    // If there are unclosed tags, close them at end of this chunk and reopen in next
-    if (openTags.length > 0) {
-      const closingTags = [...openTags].reverse().map(t => `</${t}>`).join("");
-      const openingTags = openTags.map(t => `<${t}>`).join("");
-      candidate = candidate + closingTags;
-      remaining = openingTags + remaining.substring(splitAt).trimStart();
-    } else {
-      remaining = remaining.substring(splitAt).trimStart();
-    }
-
-    chunks.push(candidate);
-  }
-
-  return chunks;
-}

package/src/core/history.ts

@@ -1,193 +0,0 @@
-/**
- * @module core/history
- * @role Shared conversation history across backends (Claude/Codex).
- * @responsibilities
- *   - Log each user↔backend exchange with backend tag
- *   - Provide "foreign" context: exchanges from the OTHER backend
- *     that the current backend hasn't seen
- *   - Persist to disk, load on startup
- * @dependencies shared/config
- * @effects Reads/writes runtime history.jsonl
- */
-
-import { existsSync, readFileSync, appendFileSync, writeFileSync, mkdirSync } from "fs";
-import { join, dirname } from "path";
-import { config } from "../shared/config";
-import { createLogger } from "../shared/logger";
-
-const log = createLogger("core");
-
-const HISTORY_PATH = join(config.arisaDir, "history.jsonl");
-const MAX_ENTRIES_PER_CHAT = 50;
-const FOREIGN_CONTEXT_MAX_AGE_MS = 30 * 60 * 1000;
-const CODEX_SWITCH_NOTICE = "Claude is out of credits right now, so I switched this reply to Codex.";
-
-interface Exchange {
-  ts: number;
-  chatId: string;
-  user: string;
-  response: string;
-  backend: "claude" | "codex";
-}
-
-let history: Exchange[] = [];
-
-// Load persisted history on import
-try {
-  if (existsSync(HISTORY_PATH)) {
-    const lines = readFileSync(HISTORY_PATH, "utf8").split("\n").filter(Boolean);
-    history = lines.map((l) => {
-      const entry = JSON.parse(l) as Exchange;
-      return { ...entry, response: normalizeResponse(entry.response) };
-    });
-    log.info(`Loaded ${history.length} history entries`);
-  }
-} catch (e) {
-  log.warn(`Failed to load history: ${e}`);
-}
-
-export function addExchange(
-  chatId: string,
-  user: string,
-  response: string,
-  backend: "claude" | "codex",
-) {
-  const normalizedResponse = normalizeResponse(response);
-  const entry: Exchange = { ts: Date.now(), chatId, user, response: normalizedResponse, backend };
-  history.push(entry);
-
-  // Prune old entries per chat
-  const chatEntries = history.filter((e) => e.chatId === chatId);
-  if (chatEntries.length > MAX_ENTRIES_PER_CHAT) {
-    const toRemove = chatEntries.length - MAX_ENTRIES_PER_CHAT;
-    let removed = 0;
-    history = history.filter((e) => {
-      if (e.chatId === chatId && removed < toRemove) {
-        removed++;
-        return false;
-      }
-      return true;
-    });
-  }
-
-  // Persist
-  try {
-    const dir = dirname(HISTORY_PATH);
-    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-    // Rewrite full file after prune to keep it clean
-    writeFileSync(HISTORY_PATH, history.map((e) => JSON.stringify(e)).join("\n") + "\n");
-  } catch (e) {
-    log.warn(`Failed to persist history: ${e}`);
-  }
-}
-
-/**
- * Returns context string with exchanges from the OTHER backend
- * that happened since the current backend was last used.
- * Returns empty string if there's nothing to inject.
- */
-export function getForeignContext(
-  chatId: string,
-  currentBackend: "claude" | "codex",
-  limit = 10,
-): string {
-  const chatHistory = history.filter((e) => e.chatId === chatId);
-  if (chatHistory.length === 0) return "";
-
-  // Find last exchange handled by current backend
-  let lastOwnIdx = -1;
-  for (let i = chatHistory.length - 1; i >= 0; i--) {
-    if (chatHistory[i].backend === currentBackend) {
-      lastOwnIdx = i;
-      break;
-    }
-  }
-
-  const cutoff = Date.now() - FOREIGN_CONTEXT_MAX_AGE_MS;
-
-  // Get foreign exchanges since then
-  const foreign = chatHistory
-    .slice(lastOwnIdx + 1)
-    .filter((e) => e.backend !== currentBackend && e.ts >= cutoff);
-
-  if (foreign.length === 0) return "";
-
-  const otherName = currentBackend === "claude" ? "Codex" : "Claude";
-  const lines = foreign
-    .slice(-limit)
-    .map((e) => `User: ${e.user}\n${otherName}: ${normalizeResponse(e.response)}`)
-    .join("\n\n");
-
-  return `[Contexto previo con ${otherName}]\n${lines}\n[Fin del contexto previo]\n\n`;
-}
-
-/**
- * Returns recent conversation history for this chat, formatted as User/Assistant pairs.
- * Trims oldest entries first if total exceeds maxChars.
- * Returns "" for new conversations.
- */
-export function getRecentHistory(
-  chatId: string,
-  limit = 10,
-  maxChars = 8000,
-): string {
-  const chatHistory = history.filter((e) => e.chatId === chatId);
-  if (chatHistory.length === 0) return "";
-
-  const recent = chatHistory.slice(-limit);
-
-  // Format exchanges
-  const formatted = recent.map(
-    (e) => `User: ${e.user}\nAssistant: ${normalizeResponse(e.response)}`,
-  );
-
-  // Trim oldest entries if total exceeds maxChars
-  let total = formatted.join("\n\n").length;
-  while (formatted.length > 1 && total > maxChars) {
-    formatted.shift();
-    total = formatted.join("\n\n").length;
-  }
-
-  if (formatted.length === 0) return "";
-
-  return `[Conversation history]\n${formatted.join("\n\n")}\n[End of conversation history]\n\n`;
-}
-
-/**
- * Removes all history entries for this chat from memory and disk.
- */
-export function clearHistory(chatId: string): void {
-  const before = history.length;
-  history = history.filter((e) => e.chatId !== chatId);
-  const removed = before - history.length;
-
-  if (removed > 0) {
-    log.info(`Cleared ${removed} history entries for chat ${chatId}`);
-    try {
-      writeFileSync(HISTORY_PATH, history.map((e) => JSON.stringify(e)).join("\n") + "\n");
-    } catch (e) {
-      log.warn(`Failed to persist history after clear: ${e}`);
-    }
-  }
-}
-
-export function getLastBackend(chatId: string): "claude" | "codex" | null {
-  for (let i = history.length - 1; i >= 0; i--) {
-    if (history[i].chatId === chatId) {
-      return history[i].backend;
-    }
-  }
-  return null;
-}
-
-function normalizeResponse(response: string): string {
-  const cleaned = response
-    .replace(/\n---CHUNK---\n/g, "\n")
-    .replace(new RegExp(`^${escapeRegExp(CODEX_SWITCH_NOTICE)}\\s*`, "m"), "")
-    .trim();
-  return cleaned;
-}
-
-function escapeRegExp(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}