arisa 2.3.55 → 3.0.0

package/cli/web-browser/index.js

@@ -0,0 +1,146 @@
+import { readFile } from "node:fs/promises";
+
+function printHelp() {
+  console.log(`web-browser\n\nUsage:\n  node index.js --help\n  node index.js run --request-file <json>\n\nExpected input:\n  {\n    "text": "weather toronto" | "https://example.com",\n    "artifact": { "text": "weather toronto" },\n    "args": {\n      "mode": "search" | "open",\n      "url": "https://example.com",\n      "maxResults": "5"\n    }\n  }\n\nBehavior:\n  - If the input looks like a URL, open the page.\n  - Otherwise, perform a web search.\n  - When possible, opening pages uses r.jina.ai with a direct fetch fallback.\n`);
+}
+
+function decodeHtml(text = "") {
+  return text
+    .replace(/&amp;/g, "&")
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&nbsp;/g, " ");
+}
+
+function stripHtml(html = "") {
+  return decodeHtml(
+    html
+      .replace(/<script[\s\S]*?<\/script>/gi, " ")
+      .replace(/<style[\s\S]*?<\/style>/gi, " ")
+      .replace(/<[^>]+>/g, " ")
+      .replace(/\s+/g, " ")
+  ).trim();
+}
+
+function normalizeUrl(value = "") {
+  const text = value.trim();
+  if (!text) return "";
+  if (/^https?:\/\//i.test(text)) return text;
+  if (/^[\w.-]+\.[a-z]{2,}(\/|$)/i.test(text)) return `https://${text}`;
+  return "";
+}
+
+function extractActualUrl(duckUrl) {
+  try {
+    const parsed = new URL(duckUrl.startsWith("//") ? `https:${duckUrl}` : duckUrl);
+    const uddg = parsed.searchParams.get("uddg");
+    return uddg ? decodeURIComponent(uddg) : parsed.toString();
+  } catch {
+    return duckUrl;
+  }
+}
+
+async function fetchText(url) {
+  const response = await fetch(url, {
+    headers: {
+      "user-agent": "Mozilla/5.0",
+      "accept-language": "es-AR,es;q=0.9,en;q=0.8"
+    },
+    redirect: "follow"
+  });
+  return { response, text: await response.text() };
+}
+
+async function searchWeb(query, maxResults = 5) {
+  const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+  const { response, text: html } = await fetchText(url);
+  if (!response.ok) throw new Error(`Search failed with status ${response.status}`);
+
+  const results = [];
+  const blocks = html.split(/<div class="result results_links[\s\S]*?web-result ">/i).slice(1);
+  for (const block of blocks) {
+    if (results.length >= maxResults) break;
+    const titleMatch = block.match(/<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/i);
+    if (!titleMatch) continue;
+    const snippetMatch = block.match(/<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i);
+    const displayUrlMatch = block.match(/<a[^>]*class="result__url"[^>]*>([\s\S]*?)<\/a>/i);
+    results.push({
+      title: stripHtml(titleMatch[2]),
+      url: extractActualUrl(titleMatch[1]),
+      snippet: stripHtml(snippetMatch?.[1] || ""),
+      displayUrl: stripHtml(displayUrlMatch?.[1] || "")
+    });
+  }
+
+  if (!results.length) {
+    return `Search: ${query}\n\nNo parseable results were found.`;
+  }
+
+  return [
+    `Search: ${query}`,
+    "",
+    ...results.flatMap((item, index) => [
+      `${index + 1}. ${item.title}`,
+      `URL: ${item.url}`,
+      `Snippet: ${item.snippet}`,
+      item.displayUrl ? `Displayed: ${item.displayUrl}` : null,
+      ""
+    ].filter(Boolean))
+  ].join("\n").trim();
+}
+
+async function openWebPage(inputUrl) {
+  const targetUrl = normalizeUrl(inputUrl);
+  if (!targetUrl) throw new Error("A valid URL is required");
+
+  const jinaUrl = `https://r.jina.ai/http://${targetUrl.replace(/^https?:\/\//i, "")}`;
+  let body = "";
+  let source = "jina-ai";
+
+  try {
+    const { response, text } = await fetchText(jinaUrl);
+    if (!response.ok) throw new Error(`r.jina.ai status ${response.status}`);
+    body = text.trim();
+  } catch {
+    const { response, text } = await fetchText(targetUrl);
+    if (!response.ok) throw new Error(`Open failed with status ${response.status}`);
+    body = stripHtml(text);
+    source = "direct-fetch";
+  }
+
+  const shortened = body.length > 12000 ? `${body.slice(0, 12000)}\n\n[content truncated]` : body;
+  return [`Page: ${targetUrl}`, `Source: ${source}`, "", shortened].join("\n").trim();
+}
+
+async function run(requestFile) {
+  const request = JSON.parse(await readFile(requestFile, "utf8"));
+  const rawInput = request.args?.url || request.text || request.artifact?.text || "";
+  const mode = request.args?.mode || (normalizeUrl(rawInput) ? "open" : "search");
+  const maxResults = Number.parseInt(request.args?.maxResults || "5", 10);
+
+  if (!rawInput.trim()) {
+    console.log(JSON.stringify({ ok: false, error: "text, artifact.text, or args.url is required" }));
+    return;
+  }
+
+  try {
+    const outputText = mode === "open"
+      ? await openWebPage(rawInput)
+      : await searchWeb(rawInput, Number.isFinite(maxResults) ? maxResults : 5);
+    console.log(JSON.stringify({ ok: true, output: { text: outputText } }));
+  } catch (error) {
+    console.log(JSON.stringify({ ok: false, error: error.message || String(error) }));
+  }
+}
+
+const args = process.argv.slice(2);
+if (!args.length || args.includes("--help") || args[0] === "help") {
+  printHelp();
+} else if (args[0] === "run") {
+  const fileIndex = args.indexOf("--request-file");
+  await run(args[fileIndex + 1]);
+} else {
+  printHelp();
+}

package/cli/web-browser/package.json

@@ -0,0 +1,6 @@
+{
+  "name": "web-browser-cli",
+  "private": true,
+  "type": "module",
+  "version": "1.0.0"
+}

package/cli/web-browser/tool.manifest.json

@@ -0,0 +1,8 @@
+{
+  "name": "web-browser",
+  "description": "Search the web and open web pages as readable text.",
+  "entry": "index.js",
+  "input": ["text/plain"],
+  "output": ["text/plain"],
+  "configSchema": {}
+}

package/package.json

@@ -1,55 +1,37 @@
 {
   "name": "arisa",
-  "version": "2.3.55",
-  "description": "Arisa - dynamic agent runtime with daemon/core architecture that evolves through user interaction",
+  "version": "3.0.0",
+  "description": "Telegram + Pi Agent modular assistant",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "arisa": "./src/index.js"
+  },
+  "scripts": {
+    "start": "node src/index.js",
+    "bootstrap": "node src/index.js --bootstrap"
+  },
   "keywords": [
-    "tinyclaw",
-    "clawbot",
-    "moltbot",
+    "telegram",
+    "pi-agent",
+    "assistant",
+    "cli",
     "openclaw",
+    "moltbot",
+    "clawbot",
     "agent",
-    "telegram",
-    "jarvis",
-    "CLAUDE.md",
     "SOUL.md",
+    "tinyclaw",
+    "jarvis",
+    "AGENTS.md",
     "clasen"
   ],
-  "preferGlobal": true,
-  "bin": {
-    "arisa": "./bin/arisa.js"
-  },
-  "files": [
-    "bin",
-    "src",
-    "scripts",
-    "CLAUDE.md",
-    "SOUL.md",
-    "README.md",
-    "tsconfig.json"
-  ],
-  "engines": {
-    "node": ">=18",
-    "bun": ">=1.0.0"
-  },
-  "scripts": {
-    "arisa": "bun ./bin/arisa.js",
-    "daemon": "bun src/daemon/index.ts",
-    "dev": "bun --watch src/core/index.ts",
-    "start": "bun src/daemon/index.ts",
-    "core": "bun src/core/index.ts"
-  },
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.32.1",
   "dependencies": {
-    "@inquirer/prompts": "^8.2.0",
-    "croner": "^9.0.0",
-    "crypto-js": "^4.2.0",
-    "deepbase": "^3.4.9",
-    "elevenlabs": "^1.59.0",
-    "grammy": "^1.21.0",
-    "openai": "^6.19.0",
-    "sharp": "^0.34.5"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "@types/crypto-js": "^4.2.2"
+    "@mariozechner/pi-coding-agent": "^0.65.0",
+    "@sinclair/typebox": "^0.34.41",
+    "grammy": "^1.42.0"
   }
 }

package/src/core/agent/agent-manager.js

@@ -0,0 +1,218 @@
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { AuthStorage, createAgentSession, ModelRegistry, SessionManager, defineTool } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+
+const agentDir = path.resolve("data/pi-agent");
+
+function getOAuthProviderForModelProvider(provider) {
+  if (provider === "openai-codex") return "openai-codex";
+  if (provider === "anthropic") return "anthropic";
+  if (provider === "google") return "google-gemini-cli";
+  if (provider === "google-antigravity") return "google-antigravity";
+  if (provider === "github-copilot") return "github-copilot";
+  return provider;
+}
+
+function normalizePiConfig(pi) {
+  const provider = pi.provider === "codex" ? "openai" : pi.provider;
+  let model = pi.model;
+  if (pi.provider === "codex") {
+    if (model === "5.4") model = "gpt-5.4";
+    else if (model === "5.4-mini") model = "gpt-5.4-mini";
+    else if (model === "5.4-nano") model = "gpt-5.4-nano";
+    else if (model === "5.4-pro") model = "gpt-5.4-pro";
+    else if (!model.startsWith("gpt-")) model = `gpt-${model}`;
+  }
+  return { provider, model };
+}
+
+export class AgentManager {
+  constructor({ config, artifactStore, toolRegistry }) {
+    this.config = config;
+    this.artifactStore = artifactStore;
+    this.toolRegistry = toolRegistry;
+    this.sessions = new Map();
+  }
+
+  setConfig(config) {
+    this.config = config;
+    this.sessions.clear();
+  }
+
+  async validatePiAgent() {
+    const authStorage = AuthStorage.create();
+    const normalized = normalizePiConfig(this.config.pi);
+    if (this.config.pi.apiKey) {
+      authStorage.setRuntimeApiKey(normalized.provider, this.config.pi.apiKey);
+    }
+
+    const modelRegistry = ModelRegistry.create(authStorage);
+    const model = modelRegistry.find(normalized.provider, normalized.model);
+    if (!model) {
+      throw new Error(`Model not found: ${this.config.pi.provider}/${this.config.pi.model} (resolved to ${normalized.provider}/${normalized.model})`);
+    }
+    const oauthProvider = getOAuthProviderForModelProvider(normalized.provider);
+    if (!this.config.pi.apiKey && !modelRegistry.hasConfiguredAuth(normalized.provider) && !authStorage.hasAuth(oauthProvider)) {
+      throw new Error(`No auth found for ${normalized.provider}. Provide a Pi API key in bootstrap, or authenticate with the internal /login flow during bootstrap.`);
+    }
+
+    const { session } = await createAgentSession({
+      authStorage,
+      modelRegistry,
+      model,
+      sessionManager: SessionManager.inMemory(),
+    });
+    await session.prompt("Reply with exactly: OK");
+  }
+
+  async getSessionContext(chatId, telegram) {
+    if (this.sessions.has(chatId)) return this.sessions.get(chatId);
+
+    await mkdir(agentDir, { recursive: true });
+    const authStorage = AuthStorage.create();
+    const normalized = normalizePiConfig(this.config.pi);
+    if (this.config.pi.apiKey) {
+      authStorage.setRuntimeApiKey(normalized.provider, this.config.pi.apiKey);
+    }
+    const modelRegistry = ModelRegistry.create(authStorage);
+    const model = modelRegistry.find(normalized.provider, normalized.model);
+    if (!model) throw new Error(`Model not found: ${this.config.pi.provider}/${this.config.pi.model} (resolved to ${normalized.provider}/${normalized.model})`);
+    const oauthProvider = getOAuthProviderForModelProvider(normalized.provider);
+    if (!this.config.pi.apiKey && !modelRegistry.hasConfiguredAuth(normalized.provider) && !authStorage.hasAuth(oauthProvider)) {
+      throw new Error(`No auth found for ${normalized.provider}. Re-run bootstrap and complete login for this provider before Telegram starts.`);
+    }
+
+    const cwd = path.resolve("data/chats", String(chatId));
+    await mkdir(cwd, { recursive: true });
+
+    const customTools = this.createTools(telegram);
+    const { session } = await createAgentSession({
+      cwd,
+      agentDir,
+      authStorage,
+      modelRegistry,
+      model,
+      customTools,
+      sessionManager: SessionManager.continueRecent(cwd)
+    });
+
+    const ctx = { session };
+    this.sessions.set(chatId, ctx);
+    return ctx;
+  }
+
+  createTools(telegram) {
+    return [
+      defineTool({
+        name: "list_tools",
+        label: "List tools",
+        description: "List registered CLI tools and their capabilities.",
+        parameters: Type.Object({}),
+        execute: async () => {
+          await this.toolRegistry.load();
+          return {
+            content: [{ type: "text", text: JSON.stringify(this.toolRegistry.list(), null, 2) }],
+            details: { tools: this.toolRegistry.list() }
+          };
+        }
+      }),
+      defineTool({
+        name: "tool_help",
+        label: "Tool help",
+        description: "Show --help text for a CLI tool.",
+        parameters: Type.Object({ name: Type.String() }),
+        execute: async (_id, params) => {
+          await this.toolRegistry.load();
+          const help = await this.toolRegistry.help(params.name);
+          return { content: [{ type: "text", text: help }], details: { help } };
+        }
+      }),
+      defineTool({
+        name: "set_tool_config",
+        label: "Set tool config",
+        description: "Write a value into cli/<tool>/config.js.",
+        parameters: Type.Object({ name: Type.String(), field: Type.String(), value: Type.String() }),
+        execute: async (_id, params) => {
+          await this.toolRegistry.load();
+          const result = await this.toolRegistry.setConfig(params.name, params.field, params.value);
+          return { content: [{ type: "text", text: JSON.stringify(result) }], details: result };
+        }
+      }),
+      defineTool({
+        name: "run_tool",
+        label: "Run tool",
+        description: "Run a CLI tool using text input or an artifactId. If config is missing, ask the user naturally and then use set_tool_config.",
+        parameters: Type.Object({
+          name: Type.String(),
+          artifactId: Type.Optional(Type.String()),
+          text: Type.Optional(Type.String()),
+          args: Type.Optional(Type.Record(Type.String(), Type.String()))
+        }),
+        execute: async (_id, params) => {
+          await this.toolRegistry.load();
+          let artifact = null;
+          if (params.artifactId) {
+            artifact = await this.artifactStore.get(params.artifactId);
+            if (!artifact) {
+              return { content: [{ type: "text", text: `Artifact not found: ${params.artifactId}` }], details: { ok: false } };
+            }
+          }
+          const result = await this.toolRegistry.run({
+            name: params.name,
+            request: {
+              artifact,
+              text: params.text,
+              args: params.args || {}
+            }
+          });
+
+          if (result.output?.text) {
+            const outArtifact = await this.artifactStore.createText({
+              text: result.output.text,
+              source: { type: "tool", toolName: params.name },
+              metadata: { tool: params.name }
+            });
+            result.output.artifactId = outArtifact.id;
+          }
+
+          if (result.output?.filePath) {
+            const generated = await this.artifactStore.createFromFile({
+              originalPath: result.output.filePath,
+              fileName: result.output.fileName || path.basename(result.output.filePath),
+              kind: result.output.kind || "file",
+              mimeType: result.output.mimeType || "application/octet-stream",
+              source: { type: "tool", toolName: params.name },
+              metadata: { tool: params.name }
+            });
+            result.output.artifactId = generated.id;
+          }
+
+          return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            details: result
+          };
+        }
+      }),
+      defineTool({
+        name: "send_audio_reply",
+        label: "Send audio reply",
+        description: "Generate speech from text with a CLI tool and send it to the current Telegram chat.",
+        parameters: Type.Object({ text: Type.String(), toolName: Type.Optional(Type.String()) }),
+        execute: async (_id, params) => {
+          await this.toolRegistry.load();
+          const toolName = params.toolName || "openai-tts";
+          const result = await this.toolRegistry.run({
+            name: toolName,
+            request: { text: params.text, args: {} }
+          });
+          if (!result.ok || !result.output?.filePath) {
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], details: result };
+          }
+          await telegram.sendAudio(result.output.filePath, params.text);
+          return { content: [{ type: "text", text: "Audio enviado por Telegram." }], details: result };
+        }
+      })
+    ];
+  }
+}

package/src/core/artifacts/artifact-store.js

@@ -0,0 +1,102 @@
+import { mkdir, readFile, writeFile, copyFile } from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+
+const rootDir = path.resolve("data/artifacts");
+const indexFile = path.resolve("data/state/artifacts.json");
+
+async function loadIndex() {
+  try {
+    return JSON.parse(await readFile(indexFile, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+async function saveIndex(items) {
+  await mkdir(path.dirname(indexFile), { recursive: true });
+  await writeFile(indexFile, `${JSON.stringify(items, null, 2)}\n`, "utf8");
+}
+
+function id() {
+  return crypto.randomUUID();
+}
+
+export class ArtifactStore {
+  constructor() {
+    this.items = null;
+  }
+
+  async init() {
+    if (!this.items) this.items = await loadIndex();
+    await mkdir(rootDir, { recursive: true });
+  }
+
+  async createText({ text, mimeType = "text/plain", source, metadata = {} }) {
+    await this.init();
+    const artifact = {
+      id: id(),
+      kind: "text",
+      mimeType,
+      text,
+      source,
+      metadata,
+      createdAt: new Date().toISOString()
+    };
+    this.items.push(artifact);
+    await saveIndex(this.items);
+    return artifact;
+  }
+
+  async createFromFile({ originalPath, fileName, kind, mimeType, source, metadata = {} }) {
+    await this.init();
+    const artifactId = id();
+    const dir = path.join(rootDir, artifactId);
+    await mkdir(dir, { recursive: true });
+    const destPath = path.join(dir, fileName);
+    await copyFile(originalPath, destPath);
+    const artifact = {
+      id: artifactId,
+      kind,
+      mimeType,
+      path: destPath,
+      source,
+      metadata,
+      createdAt: new Date().toISOString()
+    };
+    this.items.push(artifact);
+    await saveIndex(this.items);
+    return artifact;
+  }
+
+  async createGeneratedFile({ fileName, content, kind, mimeType, source, metadata = {} }) {
+    await this.init();
+    const artifactId = id();
+    const dir = path.join(rootDir, artifactId);
+    await mkdir(dir, { recursive: true });
+    const destPath = path.join(dir, fileName);
+    await writeFile(destPath, content);
+    const artifact = {
+      id: artifactId,
+      kind,
+      mimeType,
+      path: destPath,
+      source,
+      metadata,
+      createdAt: new Date().toISOString()
+    };
+    this.items.push(artifact);
+    await saveIndex(this.items);
+    return artifact;
+  }
+
+  async get(id) {
+    await this.init();
+    return this.items.find((item) => item.id === id) || null;
+  }
+
+  async listRecent(limit = 20) {
+    await this.init();
+    return [...this.items].slice(-limit).reverse();
+  }
+}

package/src/core/config/config-store.js

@@ -0,0 +1,20 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { configFile } from "../../runtime/bootstrap.js";
+
+export async function loadConfig() {
+  const raw = await readFile(configFile, "utf8");
+  return JSON.parse(raw);
+}
+
+export async function saveConfig(config) {
+  await mkdir(path.dirname(configFile), { recursive: true });
+  await writeFile(configFile, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+
+export async function updateConfig(mutator) {
+  const config = await loadConfig();
+  await mutator(config);
+  await saveConfig(config);
+  return config;
+}