arisa 2.3.55 → 3.0.1

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;
+}

package/src/core/tools/tool-registry.js

@@ -0,0 +1,117 @@
+import { readdir, readFile, writeFile, unlink } from "node:fs/promises";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+const cliRoot = path.resolve("cli");
+
+function runProcess(command, args, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { ...options, stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => { stdout += d.toString(); });
+    child.stderr.on("data", (d) => { stderr += d.toString(); });
+    child.on("close", (code) => resolve({ code, stdout, stderr }));
+  });
+}
+
+function parseConfigModule(source) {
+  const normalized = source.replace(/^export\s+default/, "return");
+  return new Function(normalized)();
+}
+
+function serializeConfigModule(config) {
+  const lines = Object.entries(config).map(([key, value]) => `  ${key}: ${JSON.stringify(value)}`);
+  return `export default {\n${lines.join(",\n")}\n};\n`;
+}
+
+export class ToolRegistry {
+  constructor() {
+    this.tools = new Map();
+  }
+
+  async load() {
+    this.tools.clear();
+    let entries = [];
+    try {
+      entries = await readdir(cliRoot, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const toolDir = path.join(cliRoot, entry.name);
+      const manifestPath = path.join(toolDir, "tool.manifest.json");
+      const configPath = path.join(toolDir, "config.js");
+      try {
+        const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+        const configSource = await readFile(configPath, "utf8");
+        const config = parseConfigModule(configSource);
+        this.tools.set(manifest.name, {
+          ...manifest,
+          dir: toolDir,
+          entry: path.join(toolDir, manifest.entry || "index.js"),
+          configPath,
+          config
+        });
+      } catch {
+        // ignore invalid tool dirs in v1
+      }
+    }
+  }
+
+  list() {
+    return [...this.tools.values()].map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input: tool.input,
+      output: tool.output,
+      configSchema: tool.configSchema || {}
+    }));
+  }
+
+  get(name) {
+    return this.tools.get(name) || null;
+  }
+
+  async help(name) {
+    const tool = this.get(name);
+    if (!tool) throw new Error(`Tool not found: ${name}`);
+    const result = await runProcess("node", [tool.entry, "--help"], { cwd: tool.dir, env: process.env });
+    return result.stdout || result.stderr;
+  }
+
+  async setConfig(name, field, value) {
+    const tool = this.get(name);
+    if (!tool) throw new Error(`Tool not found: ${name}`);
+    const config = { ...(tool.config || {}) };
+    config[field] = value;
+    await writeFile(tool.configPath, serializeConfigModule(config), "utf8");
+    tool.config = config;
+    return { ok: true, tool: name, field, configPath: tool.configPath };
+  }
+
+  async run({ name, request }) {
+    const tool = this.get(name);
+    if (!tool) throw new Error(`Tool not found: ${name}`);
+    const requestFile = path.join(tool.dir, `.request-${Date.now()}.json`);
+    await writeFile(requestFile, `${JSON.stringify(request, null, 2)}\n`, "utf8");
+    const result = await runProcess("node", [tool.entry, "run", "--request-file", requestFile], {
+      cwd: tool.dir,
+      env: process.env
+    });
+    await unlink(requestFile).catch(() => {});
+    try {
+      const parsed = JSON.parse(result.stdout || result.stderr);
+      return parsed;
+    } catch {
+      return {
+        ok: false,
+        error: `Invalid tool response for ${name}`,
+        stdout: result.stdout,
+        stderr: result.stderr
+      };
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+
+import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
+import { createApp } from "./runtime/create-app.js";
+
+const forceBootstrap = process.argv.includes("--bootstrap");
+
+async function main() {
+  await bootstrapIfNeeded({ force: forceBootstrap });
+  try {
+    const app = await createApp();
+    await app.start();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("No auth found")) {
+      console.log(`\n${message}\n`);
+      console.log("Reopening bootstrap so you can provide a Pi API key or switch to a provider you already authenticated with.\n");
+      await bootstrapIfNeeded({ force: true });
+      const app = await createApp();
+      await app.start();
+      return;
+    }
+    throw error;
+  }
+}
+
+await main();

package/src/runtime/bootstrap.js

@@ -0,0 +1,213 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { spawn } from "node:child_process";
+import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+
+const stateDir = path.resolve("data/state");
+const configFile = path.join(stateDir, "config.json");
+
+async function exists(file) {
+  try {
+    await readFile(file, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getBootstrapModels() {
+  const authStorage = AuthStorage.create();
+  const modelRegistry = ModelRegistry.create(authStorage);
+  const preferred = [
+    ["openai-codex", "gpt-5.4"],
+    ["openai-codex", "gpt-5.4-mini"],
+    ["openai", "gpt-4.1"],
+    ["anthropic", "claude-sonnet-4-6"],
+    ["anthropic", "claude-opus-4-6"],
+    ["google", "gemini-3.1-pro-preview"],
+  ];
+
+  const models = preferred
+    .map(([provider, model]) => modelRegistry.find(provider, model))
+    .filter(Boolean)
+    .map((model) => ({ provider: model.provider, id: model.id, label: `${model.provider}/${model.id}` }));
+
+  if (!models.length) {
+    return modelRegistry.getAll().slice(0, 10).map((model) => ({
+      provider: model.provider,
+      id: model.id,
+      label: `${model.provider}/${model.id}`,
+    }));
+  }
+
+  return models;
+}
+
+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 hasExistingPiAuth(provider) {
+  const authStorage = AuthStorage.create();
+  const modelRegistry = ModelRegistry.create(authStorage);
+  const oauthProvider = getOAuthProviderForModelProvider(provider);
+  return modelRegistry.hasConfiguredAuth(provider) || authStorage.hasAuth(oauthProvider);
+}
+
+async function maybeOpenExternal(url) {
+  if (!url) return;
+  await new Promise((resolve) => {
+    let child;
+    if (process.platform === "darwin") {
+      child = spawn("open", [url], { stdio: "ignore" });
+    } else if (process.platform === "win32") {
+      child = spawn("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+    } else {
+      child = spawn("xdg-open", [url], { stdio: "ignore" });
+    }
+    child.on("exit", () => resolve());
+    child.on("error", () => resolve());
+  });
+}
+
+async function runInternalPiLogin(provider, rl) {
+  const authStorage = AuthStorage.create();
+  const oauthProvider = getOAuthProviderForModelProvider(provider);
+  const available = authStorage.getOAuthProviders();
+  const selected = available.find((item) => item.id === oauthProvider);
+  if (!selected) {
+    throw new Error(`No internal OAuth login flow is available for ${provider}.`);
+  }
+
+  let manualCodeResolve;
+  let manualCodeReject;
+  const manualCodePromise = new Promise((resolve, reject) => {
+    manualCodeResolve = resolve;
+    manualCodeReject = reject;
+  });
+
+  await authStorage.login(oauthProvider, {
+    onAuth: async ({ url, instructions }) => {
+      console.log(`${instructions || "Open this URL to continue authentication:"}\n${url}\n`);
+      await maybeOpenExternal(url);
+      if (selected.usesCallbackServer) {
+        const pasted = (await rl.question("Paste the redirect URL here if the browser does not return automatically, or press Enter to keep waiting: ")).trim();
+        if (pasted && manualCodeResolve) {
+          manualCodeResolve(pasted);
+          manualCodeResolve = undefined;
+        }
+      }
+    },
+    onDeviceCode: async ({ userCode, verificationUri }) => {
+      console.log(`Open this URL: ${verificationUri}`);
+      console.log(`Then enter code: ${userCode}\n`);
+      await maybeOpenExternal(verificationUri);
+    },
+    onPrompt: async ({ message }) => {
+      return (await rl.question(`${message} `)).trim();
+    },
+    onProgress: (message) => {
+      console.log(message);
+    },
+    onManualCodeInput: () => manualCodePromise,
+  }).finally(() => {
+    if (manualCodeResolve) {
+      manualCodeResolve("");
+      manualCodeResolve = undefined;
+    }
+    manualCodeReject = undefined;
+  });
+}
+
+export async function bootstrapIfNeeded({ force = false } = {}) {
+  await mkdir(stateDir, { recursive: true });
+  if (!force && await exists(configFile)) return;
+
+  const rl = readline.createInterface({ input, output });
+  const ask = async (label, fallback = "") => {
+    const suffix = fallback ? ` (${fallback})` : "";
+    const value = (await rl.question(`${label}${suffix}: `)).trim();
+    return value || fallback;
+  };
+
+  const askYesNo = async (label, fallback = true) => {
+    const hint = fallback ? "Y/n" : "y/N";
+    const value = (await rl.question(`${label} (${hint}): `)).trim().toLowerCase();
+    if (!value) return fallback;
+    return value === "y" || value === "yes";
+  };
+
+  console.log("\n== Arisa bootstrap ==\n");
+  console.log("Telegram bot token tip: get it from https://t.me/BotFather");
+  const telegramApiKey = await ask("Telegram API key / bot token");
+  const telegramMaxChatIds = Number(await ask("Maximum authorized chat IDs", "1"));
+
+  const models = getBootstrapModels();
+  console.log("\nAvailable Pi models:");
+  models.forEach((model, index) => {
+    const authStatus = hasExistingPiAuth(model.provider) ? "auth: configured" : "auth: missing";
+    const providerLabel = model.provider;
+    console.log(`${index + 1}. ${providerLabel}/${model.id} (${authStatus})`);
+  });
+  const selectedIndex = Number(await ask("Select Pi model by number", "1"));
+  const selectedModel = models[Math.max(0, Math.min(models.length - 1, selectedIndex - 1))];
+  const selectedAuthReady = hasExistingPiAuth(selectedModel.provider);
+  console.log(`Selected model: ${selectedModel.provider}/${selectedModel.id}`);
+  console.log(`Existing Pi auth for ${selectedModel.provider}: ${selectedAuthReady ? "yes" : "no"}`);
+  console.log("Pi auth tip: if this provider supports Pi login, leaving the API key empty will start the internal login flow.");
+
+  let piApiKey = "";
+  while (true) {
+    piApiKey = (await rl.question(`Pi API key for ${selectedModel.provider} (optional): `)).trim();
+    if (piApiKey) break;
+    if (hasExistingPiAuth(selectedModel.provider)) break;
+
+    const oauthProvider = getOAuthProviderForModelProvider(selectedModel.provider);
+    const supportsInternalLogin = oauthProvider !== selectedModel.provider || ["anthropic", "openai-codex", "google-gemini-cli", "google-antigravity", "github-copilot"].includes(oauthProvider);
+    if (!supportsInternalLogin) {
+      console.log(`No existing Pi auth found for ${selectedModel.provider}. This provider requires an API key.`);
+      continue;
+    }
+
+    console.log(`No existing Pi auth found for ${selectedModel.provider}. Starting internal Pi login...`);
+    try {
+      await runInternalPiLogin(selectedModel.provider, rl);
+    } catch (error) {
+      console.log(`Internal Pi login failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
+    if (hasExistingPiAuth(selectedModel.provider)) {
+      console.log(`Detected Pi auth for ${selectedModel.provider}. Continuing bootstrap.`);
+      break;
+    }
+
+    console.log(`Pi auth for ${selectedModel.provider} is still missing after login.`);
+  }
+
+  const config = {
+    telegram: {
+      apiKey: telegramApiKey,
+      maxChatIds: telegramMaxChatIds,
+      authorizedChatIds: []
+    },
+    pi: {
+      provider: selectedModel.provider,
+      model: selectedModel.id,
+      apiKey: piApiKey
+    },
+    createdAt: new Date().toISOString()
+  };
+
+  await writeFile(configFile, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+  rl.close();
+  console.log(`\nConfig saved to ${configFile}\n`);
+}
+
+export { configFile };

package/src/runtime/create-app.js

@@ -0,0 +1,22 @@
+import { loadConfig, saveConfig, updateConfig } from "../core/config/config-store.js";
+import { ArtifactStore } from "../core/artifacts/artifact-store.js";
+import { ToolRegistry } from "../core/tools/tool-registry.js";
+import { AgentManager } from "../core/agent/agent-manager.js";
+import { createTelegramBot } from "../transport/telegram/bot.js";
+
+export async function createApp() {
+  const config = await loadConfig();
+  const artifactStore = new ArtifactStore();
+  const toolRegistry = new ToolRegistry();
+  await toolRegistry.load();
+
+  const agentManager = new AgentManager({ config, artifactStore, toolRegistry });
+  const bot = await createTelegramBot({ config, artifactStore, toolRegistry, agentManager, saveConfig, updateConfig });
+
+  return {
+    async start() {
+      await agentManager.validatePiAgent();
+      await bot.start();
+    }
+  };
+}

package/src/transport/telegram/auth.js

@@ -0,0 +1,13 @@
+export async function authorizeChat({ config, chatId, saveConfig }) {
+  if (config.telegram.authorizedChatIds.includes(chatId)) {
+    return { ok: true, firstTime: false };
+  }
+
+  if (config.telegram.authorizedChatIds.length >= config.telegram.maxChatIds) {
+    return { ok: false, reason: "max-chat-ids" };
+  }
+
+  config.telegram.authorizedChatIds.push(chatId);
+  await saveConfig(config);
+  return { ok: true, firstTime: true };
+}

package/src/transport/telegram/bot.js

@@ -0,0 +1,214 @@
+import { Bot, InputFile } from "grammy";
+import { authorizeChat } from "./auth.js";
+import { captureIncomingArtifact } from "./media.js";
+
+function buildPrompt({ ctx, artifact, transcript }) {
+  const parts = [
+    `New Telegram message.`,
+    `chatId: ${ctx.chat.id}`,
+    `userId: ${ctx.from.id}`,
+    `username: ${ctx.from.username || "(no username)"}`,
+    `messageId: ${ctx.msg.message_id}`
+  ];
+
+  if (ctx.message?.text) parts.push(`text: ${ctx.message.text}`);
+  if (artifact?.path) parts.push(`artifactPath: ${artifact.path}`);
+  if (artifact?.id) parts.push(`artifactId: ${artifact.id}`);
+  if (artifact?.mimeType) parts.push(`mimeType: ${artifact.mimeType}`);
+  if (artifact?.kind) parts.push(`kind: ${artifact.kind}`);
+  if (transcript) {
+    parts.push(`transcriptArtifactId: ${transcript.id}`);
+    parts.push(`transcriptText: ${transcript.text}`);
+    parts.push(`Important: the incoming audio has already been transcribed. Use the transcript as the user message content. Do not answer with a raw transcription unless the user explicitly asked for one.`);
+  }
+
+  parts.push(`If you need a CLI tool, use list_tools/tool_help/run_tool.`);
+  parts.push(`If a tool config is missing, ask the user naturally and then use set_tool_config.`);
+  parts.push(`If the user wants audio output, use send_audio_reply.`);
+  return parts.join("\n");
+}
+
+async function maybeTranscribeIncomingAudio({ artifact, toolRegistry, artifactStore }) {
+  if (!artifact || artifact.kind !== "audio") return { transcript: null };
+
+  const result = await toolRegistry.run({
+    name: "openai-transcribe",
+    request: {
+      artifact,
+      args: {}
+    }
+  });
+
+  if (!result.ok) {
+    return { transcript: null, toolResult: result };
+  }
+
+  if (!result.output?.text) {
+    return { transcript: null, toolResult: { ok: false, error: "Transcription returned no text." } };
+  }
+
+  const transcript = await artifactStore.createText({
+    text: result.output.text,
+    source: { type: "tool", toolName: "openai-transcribe" },
+    metadata: { fromArtifactId: artifact.id, tool: "openai-transcribe" }
+  });
+
+  return { transcript, toolResult: result };
+}
+
+async function collectText(session, prompt) {
+  let text = "";
+  const unsubscribe = session.subscribe((event) => {
+    if (event.type === "message_update" && event.assistantMessageEvent.type === "text_delta") {
+      text += event.assistantMessageEvent.delta;
+    }
+  });
+  await session.prompt(prompt);
+  unsubscribe();
+  return text.trim();
+}
+
+async function withTyping(ctx, work) {
+  await ctx.api.sendChatAction(ctx.chat.id, "typing");
+  const timer = setInterval(() => {
+    ctx.api.sendChatAction(ctx.chat.id, "typing").catch(() => {});
+  }, 4000);
+
+  try {
+    return await work();
+  } finally {
+    clearInterval(timer);
+  }
+}
+
+export async function createTelegramBot({ config, artifactStore, toolRegistry, agentManager, saveConfig, updateConfig }) {
+  const bot = new Bot(config.telegram.apiKey);
+  const perChatState = new Map();
+
+  function getChatState(chatId) {
+    if (!perChatState.has(chatId)) {
+      perChatState.set(chatId, { processing: false, nextPrompt: "" });
+    }
+    return perChatState.get(chatId);
+  }
+
+  async function buildIncomingPrompt(ctx) {
+    const artifact = await captureIncomingArtifact(ctx, artifactStore);
+    const { transcript, toolResult } = await maybeTranscribeIncomingAudio({ artifact, toolRegistry, artifactStore });
+    if (artifact?.kind === "audio" && !transcript) {
+      if (toolResult?.missingConfig?.includes("OPENAI_API_KEY")) {
+        throw new Error("I need the OpenAI API key for cli/openai-transcribe/config.js before I can transcribe incoming audio.");
+      }
+      throw new Error(toolResult?.error || "Audio transcription failed.");
+    }
+    return buildPrompt({ ctx, artifact, transcript });
+  }
+
+  async function processPrompt(ctx, prompt) {
+    const telegram = {
+      sendAudio: async (filePath, caption) => ctx.replyWithAudio(new InputFile(filePath), { caption })
+    };
+    return withTyping(ctx, async () => {
+      const { session } = await agentManager.getSessionContext(ctx.chat.id, telegram);
+      const text = await collectText(session, prompt);
+      if (text) await ctx.reply(text.slice(0, 4000));
+    });
+  }
+
+  async function enqueueOrProcess(ctx) {
+    const chatState = getChatState(ctx.chat.id);
+    const incomingPrompt = await buildIncomingPrompt(ctx);
+
+    if (chatState.processing) {
+      chatState.nextPrompt = chatState.nextPrompt
+        ? `${chatState.nextPrompt}\n\n${incomingPrompt}`
+        : incomingPrompt;
+      return ctx.reply("Queued. I will process this right after the current task finishes.");
+    }
+
+    chatState.processing = true;
+    let currentPrompt = incomingPrompt;
+
+    while (currentPrompt) {
+      try {
+        await processPrompt(ctx, currentPrompt);
+      } finally {
+        if (chatState.nextPrompt) {
+          currentPrompt = chatState.nextPrompt;
+          chatState.nextPrompt = "";
+        } else {
+          currentPrompt = "";
+        }
+      }
+    }
+
+    chatState.processing = false;
+  }
+
+  bot.catch((error) => {
+    console.error("Telegram bot error:", error);
+  });
+
+  bot.command("start", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig });
+    if (!auth.ok) return ctx.reply("Private bot. Access denied.");
+    return ctx.reply(auth.firstTime ? "This chat is now authorized for Arisa." : "Arisa is ready.");
+  });
+
+  bot.command("pi_api_key", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig });
+    if (!auth.ok) return ctx.reply("Private bot. Access denied.");
+
+    const apiKey = ctx.match?.trim();
+    if (!apiKey) {
+      return ctx.reply("Usage: /pi_api_key <your_api_key>");
+    }
+
+    const nextConfig = await updateConfig((current) => {
+      current.pi.apiKey = apiKey;
+    });
+    config.pi.apiKey = nextConfig.pi.apiKey;
+    agentManager.setConfig(nextConfig);
+    return ctx.reply(`Saved Pi API key for ${nextConfig.pi.provider}.`);
+  });
+
+  bot.command("pi_model", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig });
+    if (!auth.ok) return ctx.reply("Private bot. Access denied.");
+
+    const value = ctx.match?.trim();
+    if (!value || !value.includes("/")) {
+      return ctx.reply("Usage: /pi_model <provider/model>");
+    }
+
+    const [provider, model] = value.split("/");
+    const nextConfig = await updateConfig((current) => {
+      current.pi.provider = provider.trim();
+      current.pi.model = model.trim();
+    });
+    config.pi.provider = nextConfig.pi.provider;
+    config.pi.model = nextConfig.pi.model;
+    agentManager.setConfig(nextConfig);
+    return ctx.reply(`Saved Pi model ${nextConfig.pi.provider}/${nextConfig.pi.model}.`);
+  });
+
+  bot.on("message", async (ctx) => {
+    const auth = await authorizeChat({ config, chatId: ctx.chat.id, saveConfig });
+    if (!auth.ok) return ctx.reply("Private bot. Access denied.");
+
+    try {
+      await enqueueOrProcess(ctx);
+    } catch (error) {
+      const chatState = getChatState(ctx.chat.id);
+      chatState.processing = false;
+      const message = error instanceof Error ? error.message : String(error);
+      await ctx.reply(`Error: ${message}`);
+    }
+  });
+
+  return {
+    async start() {
+      await bot.start();
+    }
+  };
+}