arisa 3.1.6 → 3.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arisa",
-  "version": "3.1.6",
+  "version": "3.2.0",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

package/src/core/artifacts/normalize-for-reasoning.js

@@ -1,7 +1,9 @@
 function mimeMatches(pattern, mimeType = "") {
-  if (!pattern || !mimeType) return false;
-  if (pattern === mimeType) return true;
-  if (pattern.endsWith("/*")) return mimeType.startsWith(`${pattern.slice(0, -2)}/`);
+  const normalizedMimeType = mimeType.split(";")[0].trim().toLowerCase();
+  const normalizedPattern = pattern?.trim().toLowerCase();
+  if (!normalizedPattern || !normalizedMimeType) return false;
+  if (normalizedPattern === normalizedMimeType) return true;
+  if (normalizedPattern.endsWith("/*")) return normalizedMimeType.startsWith(`${normalizedPattern.slice(0, -2)}/`);
   return false;
 }
 
@@ -20,8 +22,9 @@ function looksLikeAudioTranscriptionTool(tool) {
 }
 
 export function shouldNormalizeArtifactToText(artifact, desiredMimeType = "text/plain") {
+  const mimeType = artifact?.mimeType?.split(";")[0].trim().toLowerCase();
   return desiredMimeType === "text/plain"
-    && (artifact?.mimeType?.startsWith("audio/") || artifact?.mimeType?.startsWith("video/"));
+    && (mimeType?.startsWith("audio/") || mimeType?.startsWith("video/"));
 }
 
 export function selectPipeTool({ toolRegistry, artifact, desiredMimeType }) {

package/src/core/tools/daemon-processes.js

@@ -4,9 +4,6 @@ import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { getToolStateDir, toolStateDir } from "../../runtime/paths.js";
 
-export const OWNER_HEARTBEAT_INTERVAL_MS = 2000;
-export const OWNER_HEARTBEAT_TTL_MS = 10000;
-
 export function daemonPaths(toolName) {
   const root = getToolStateDir(toolName);
   return {
@@ -54,9 +51,11 @@ async function waitForExit(pid, timeoutMs) {
 export async function stopManagedDaemon(toolName, { signal = "SIGTERM", forceAfterMs = 3000 } = {}) {
   const paths = daemonPaths(toolName);
   const { pid } = await readJson(paths.pidFile, {});
+  let stopped = false;
   if (isProcessAlive(pid)) {
     try {
       process.kill(pid, signal);
+      stopped = true;
     } catch {}
     if (signal !== "SIGKILL" && forceAfterMs > 0 && !(await waitForExit(pid, forceAfterMs))) {
       try {
@@ -65,19 +64,24 @@ export async function stopManagedDaemon(toolName, { signal = "SIGTERM", forceAft
     }
   }
   await rm(paths.pidFile, { force: true });
+  return { toolName, pid: pid || null, stopped };
 }
 
-export async function startManagedDaemon({ toolName, entryPath, beforeStart = null, ownerEnv = {} }) {
+export async function startManagedDaemon({ toolName, entryPath, beforeStart = null, autoStart = true }) {
   const paths = daemonPaths(toolName);
   await mkdir(paths.commandsDir, { recursive: true });
 
   const current = await readJson(paths.pidFile, {});
   if (isProcessAlive(current.pid)) {
-    const sameOwner = !ownerEnv.ARISA_TOOL_OWNER_TOKEN
-      || current.ownerToken === ownerEnv.ARISA_TOOL_OWNER_TOKEN;
-    if (sameOwner) return current.pid;
-    await stopManagedDaemon(toolName);
+    await writeJson(paths.metaFile, {
+      toolName,
+      entryPath,
+      autoStart,
+      lastStartedAt: current.startedAt || new Date().toISOString()
+    });
+    return current.pid;
   }
+  await rm(paths.pidFile, { force: true });
 
   await rm(paths.commandsDir, { recursive: true, force: true });
   await mkdir(paths.commandsDir, { recursive: true });
@@ -88,26 +92,21 @@ export async function startManagedDaemon({ toolName, entryPath, beforeStart = nu
     const child = spawn(process.execPath, [entryPath, "daemon"], {
       detached: false,
       stdio: ["ignore", out, out],
-      env: { ...process.env, ...ownerEnv }
+      env: process.env
     });
     child.unref();
 
     const startedAt = new Date().toISOString();
     const record = {
       pid: child.pid,
-      startedAt,
-      ownerPid: Number.parseInt(ownerEnv.ARISA_OWNER_PID || "", 10) || null,
-      ownerToken: ownerEnv.ARISA_TOOL_OWNER_TOKEN || ""
+      startedAt
     };
     await writeJson(paths.pidFile, record);
     await writeJson(paths.metaFile, {
       toolName,
       entryPath,
-      autoStart: true,
-      lastStartedAt: startedAt,
-      ownerFile: ownerEnv.ARISA_TOOL_OWNER_FILE || "",
-      ownerPid: record.ownerPid,
-      ownerToken: record.ownerToken
+      autoStart,
+      lastStartedAt: startedAt
     });
     return child.pid;
   } finally {

package/src/core/tools/daemon-runtime.js

@@ -2,8 +2,6 @@ import crypto from "node:crypto";
 import { mkdir, readdir, rename, unlink } from "node:fs/promises";
 import path from "node:path";
 import {
-  OWNER_HEARTBEAT_INTERVAL_MS,
-  OWNER_HEARTBEAT_TTL_MS,
   daemonPaths,
   isProcessAlive,
   readJson,
@@ -40,12 +38,7 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
     return startManagedDaemon({
       toolName,
       entryPath,
-      beforeStart,
-      ownerEnv: {
-        ARISA_OWNER_PID: process.env.ARISA_OWNER_PID,
-        ARISA_TOOL_OWNER_FILE: process.env.ARISA_TOOL_OWNER_FILE,
-        ARISA_TOOL_OWNER_TOKEN: process.env.ARISA_TOOL_OWNER_TOKEN
-      }
+      beforeStart
     });
   }
 
@@ -53,39 +46,6 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
     await stopManagedDaemon(toolName);
   }
 
-  function installOwnerWatch() {
-    const ownerFile = process.env.ARISA_TOOL_OWNER_FILE;
-    const ownerToken = process.env.ARISA_TOOL_OWNER_TOKEN;
-    if (!ownerFile || !ownerToken) return;
-
-    let exiting = false;
-    async function exitIfOrphaned(message) {
-      if (exiting) return;
-      exiting = true;
-      await writeStatus({ state: "stopped", message });
-      process.exit(0);
-    }
-
-    const timer = setInterval(async () => {
-      const owner = await readJson(ownerFile, null);
-      if (!owner || owner.token !== ownerToken) {
-        await exitIfOrphaned("Arisa owner stopped");
-        return;
-      }
-
-      const heartbeatAt = Date.parse(owner.heartbeatAt || "");
-      if (!Number.isFinite(heartbeatAt) || Date.now() - heartbeatAt > OWNER_HEARTBEAT_TTL_MS) {
-        await exitIfOrphaned("Arisa owner heartbeat expired");
-        return;
-      }
-
-      if (!isProcessAlive(owner.pid)) {
-        await exitIfOrphaned("Arisa owner process exited");
-      }
-    }, OWNER_HEARTBEAT_INTERVAL_MS);
-    timer.unref();
-  }
-
   async function waitReady({ timeoutMs = 120000, readyStates = ["ready"] } = {}) {
     const startTime = Date.now();
     while (Date.now() - startTime < timeoutMs) {
@@ -143,7 +103,6 @@ export function createDaemonRuntime({ toolName, entryPath, beforeStart = null })
   }
 
   async function workLoop({ processJob, idleTimeoutMs = 0, intervalMs = 250 }) {
-    installOwnerWatch();
     let lastActivity = Date.now();
     setInterval(async () => {
       try {

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

@@ -25,9 +25,8 @@ function runProcess(command, args, options = {}) {
 }
 
 export class ToolRegistry {
-  constructor({ logger, processOwnerEnv = {} } = {}) {
+  constructor({ logger } = {}) {
     this.logger = logger;
-    this.processOwnerEnv = processOwnerEnv;
     this.tools = new Map();
     this.skillRegistry = new SkillRegistry();
   }
@@ -154,7 +153,7 @@ export class ToolRegistry {
     await writeFile(requestFile, `${JSON.stringify(enrichedRequest, null, 2)}\n`, "utf8");
     const result = await runProcess("node", [tool.entry, "run", "--request-file", requestFile], {
       cwd: tool.dir,
-      env: { ...process.env, ...this.processOwnerEnv }
+      env: process.env
     });
     await unlink(requestFile).catch(() => {});
     await rmdir(tmpDir).catch(() => {});

package/src/runtime/create-app.js

@@ -53,7 +53,7 @@ export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpR
 
   const artifactStore = new ArtifactStore();
   const toolProcessSupervisor = createToolProcessSupervisor({ logger });
-  const toolRegistry = new ToolRegistry({ logger, processOwnerEnv: toolProcessSupervisor.env() });
+  const toolRegistry = new ToolRegistry({ logger });
   const taskStore = new TaskStore();
   await toolRegistry.load();
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);

package/src/runtime/paths.js

@@ -7,7 +7,6 @@ export const stateDir = path.join(arisaHomeDir, "state");
 export const configFile = path.join(stateDir, "config.json");
 export const servicePidFile = path.join(stateDir, "arisa.pid");
 export const serviceLogFile = path.join(stateDir, "arisa.log");
-export const toolDaemonOwnerFile = path.join(stateDir, "tool-daemon-owner.json");
 export const tasksFile = path.join(stateDir, "tasks.json");
 export const toolsDir = path.join(arisaHomeDir, "tools");
 export const chatsDir = path.join(arisaHomeDir, "chats");

package/src/runtime/tool-process-supervisor.js

@@ -1,14 +1,12 @@
-import crypto from "node:crypto";
 import { access, rm } from "node:fs/promises";
 import {
   daemonPaths,
+  isProcessAlive,
   listRegisteredDaemons,
   readJson,
-  startManagedDaemon,
-  stopManagedDaemon,
-  writeJson
+  startManagedDaemon
 } from "../core/tools/daemon-processes.js";
-import { ensureArisaHome, toolDaemonOwnerFile } from "./paths.js";
+import { ensureArisaHome } from "./paths.js";
 
 async function fileExists(file) {
   try {
@@ -20,36 +18,10 @@ async function fileExists(file) {
 }
 
 export function createToolProcessSupervisor({ logger } = {}) {
-  const token = crypto.randomUUID();
-  let heartbeatTimer = null;
   let running = false;
 
-  const ownerEnv = {
-    ARISA_OWNER_PID: String(process.pid),
-    ARISA_TOOL_OWNER_FILE: toolDaemonOwnerFile,
-    ARISA_TOOL_OWNER_TOKEN: token
-  };
-
-  async function writeHeartbeat() {
-    await writeJson(toolDaemonOwnerFile, {
-      pid: process.pid,
-      token,
-      heartbeatAt: new Date().toISOString()
-    });
-  }
-
-  async function startHeartbeat() {
+  async function reconcileDaemons() {
     await ensureArisaHome();
-    await writeHeartbeat();
-    heartbeatTimer = setInterval(() => {
-      writeHeartbeat().catch((error) => {
-        logger?.error("tools", `tool daemon heartbeat failed: ${error instanceof Error ? error.message : String(error)}`);
-      });
-    }, 2000);
-    heartbeatTimer.unref();
-  }
-
-  async function restartRegisteredDaemons() {
     for (const record of await listRegisteredDaemons()) {
       if (!record.autoStart) continue;
       if (!(await fileExists(record.entryPath))) {
@@ -59,52 +31,33 @@ export function createToolProcessSupervisor({ logger } = {}) {
 
       const paths = daemonPaths(record.toolName);
       const { pid } = await readJson(paths.pidFile, {});
+      if (isProcessAlive(pid)) {
+        logger?.log("tools", `adopted managed daemon ${record.toolName} (pid ${pid})`);
+        continue;
+      }
       if (pid) {
-        await stopManagedDaemon(record.toolName);
+        await rm(paths.pidFile, { force: true });
+        logger?.log("tools", `removed stale daemon pid for ${record.toolName} (${pid})`);
       }
 
       logger?.log("tools", `starting managed daemon ${record.toolName}`);
       await startManagedDaemon({
         toolName: record.toolName,
-        entryPath: record.entryPath,
-        ownerEnv
+        entryPath: record.entryPath
       });
     }
   }
 
-  async function stopRegisteredDaemons() {
-    for (const record of await listRegisteredDaemons()) {
-      logger?.log("tools", `stopping managed daemon ${record.toolName}`);
-      await stopManagedDaemon(record.toolName);
-    }
-  }
-
-  async function removeOwnerFile() {
-    const current = await readJson(toolDaemonOwnerFile, null);
-    if (current?.token === token) {
-      await rm(toolDaemonOwnerFile, { force: true });
-    }
-  }
-
   return {
-    env() {
-      return ownerEnv;
-    },
-
     async start() {
       if (running) return;
       running = true;
-      await startHeartbeat();
-      await restartRegisteredDaemons();
+      await reconcileDaemons();
     },
 
     async stop() {
       if (!running) return;
       running = false;
-      if (heartbeatTimer) clearInterval(heartbeatTimer);
-      heartbeatTimer = null;
-      await stopRegisteredDaemons();
-      await removeOwnerFile();
     }
   };
 }

package/src/transport/telegram/media.js

@@ -6,6 +6,28 @@ async function downloadToBuffer(ctx, fileId) {
   return Buffer.from(await response.arrayBuffer());
 }
 
+function mimeTypeFromAudioFileName(fileName = "") {
+  const extension = fileName.toLowerCase().split(".").pop();
+  return {
+    flac: "audio/flac",
+    m4a: "audio/mp4",
+    mp3: "audio/mpeg",
+    mp4: "audio/mp4",
+    mpeg: "audio/mpeg",
+    mpga: "audio/mpga",
+    ogg: "audio/ogg",
+    opus: "audio/ogg",
+    wav: "audio/wav",
+    webm: "audio/webm"
+  }[extension] || "";
+}
+
+function normalizeDocumentMimeType(document) {
+  const mimeType = document.mime_type || "";
+  if (mimeType && mimeType !== "application/octet-stream") return mimeType;
+  return mimeTypeFromAudioFileName(document.file_name) || mimeType || "application/octet-stream";
+}
+
 function incomingCaptionMetadata(ctx) {
   return ctx.message?.caption ? { caption: ctx.message.caption } : {};
 }
@@ -33,6 +55,26 @@ export async function captureIncomingArtifact(ctx, artifactStore) {
     });
   }
 
+  if (ctx.message?.audio) {
+    const audio = ctx.message.audio;
+    const fileName = audio.file_name || `${chatId}-${ctx.msg.message_id}`;
+    const content = await downloadToBuffer(ctx, audio.file_id);
+    return store.createGeneratedFile({
+      fileName,
+      content,
+      kind: "audio",
+      mimeType: audio.mime_type || "audio/mpeg",
+      source: baseSource,
+      metadata: {
+        duration: audio.duration,
+        performer: audio.performer,
+        title: audio.title,
+        fileSize: audio.file_size,
+        ...incomingCaptionMetadata(ctx)
+      }
+    });
+  }
+
   if (ctx.message?.video) {
     const video = ctx.message.video;
     const fileName = video.file_name || `${chatId}-${ctx.msg.message_id}.mp4`;
@@ -54,13 +96,15 @@ export async function captureIncomingArtifact(ctx, artifactStore) {
   }
 
   if (ctx.message?.document) {
-    const fileName = ctx.message.document.file_name || `${chatId}-${ctx.msg.message_id}`;
-    const content = await downloadToBuffer(ctx, ctx.message.document.file_id);
+    const document = ctx.message.document;
+    const fileName = document.file_name || `${chatId}-${ctx.msg.message_id}`;
+    const mimeType = normalizeDocumentMimeType(document);
+    const content = await downloadToBuffer(ctx, document.file_id);
     return store.createGeneratedFile({
       fileName,
       content,
-      kind: "document",
-      mimeType: ctx.message.document.mime_type || "application/octet-stream",
+      kind: mimeType.startsWith("audio/") ? "audio" : "document",
+      mimeType,
       source: baseSource,
       metadata: incomingCaptionMetadata(ctx)
     });

package/tools/openai-transcribe/index.js

@@ -8,8 +8,55 @@ import { getToolConfigPath } from "../../src/runtime/paths.js";
 const toolName = "openai-transcribe";
 const config = await loadToolConfig(toolName, defaults);
 
+const supportedUploadExtensions = new Set([
+  ".flac",
+  ".m4a",
+  ".mp3",
+  ".mp4",
+  ".mpeg",
+  ".mpga",
+  ".ogg",
+  ".wav",
+  ".webm"
+]);
+
+const mimeUploadExtensions = new Map([
+  ["audio/aac", ".m4a"],
+  ["audio/flac", ".flac"],
+  ["audio/m4a", ".m4a"],
+  ["audio/mp3", ".mp3"],
+  ["audio/mp4", ".m4a"],
+  ["audio/mpeg", ".mp3"],
+  ["audio/mpga", ".mpga"],
+  ["audio/ogg", ".ogg"],
+  ["audio/opus", ".ogg"],
+  ["audio/wav", ".wav"],
+  ["audio/wave", ".wav"],
+  ["audio/webm", ".webm"],
+  ["audio/x-m4a", ".m4a"],
+  ["audio/x-wav", ".wav"],
+  ["video/mp4", ".mp4"],
+  ["video/webm", ".webm"]
+]);
+
+function baseMimeType(mimeType = "") {
+  return mimeType.split(";")[0].trim().toLowerCase();
+}
+
+function uploadFileNameForArtifact(artifact) {
+  const currentName = path.basename(artifact.path);
+  const currentExtension = path.extname(currentName).toLowerCase();
+  if (supportedUploadExtensions.has(currentExtension)) return currentName;
+
+  const extension = mimeUploadExtensions.get(baseMimeType(artifact.mimeType));
+  if (!extension) return currentName;
+
+  const parsed = path.parse(currentName);
+  return `${parsed.name || "audio"}${extension}`;
+}
+
 function printHelp() {
-  console.log(`openai-transcribe\n\nUsage:\n  node index.js --help\n  node index.js run --request-file <json>\n\nExpected input:\n  {\n    "artifact": { "path": "/abs/media.ogg", "mimeType": "audio/ogg" },\n    "args": {}\n  }\n\nConfig at ${getToolConfigPath(toolName)}:\n  OPENAI_API_KEY\n  MODEL\n`);
+  console.log(`openai-transcribe\n\nUsage:\n  node index.js --help\n  node index.js run --request-file <json>\n\nExpected input:\n  {\n    "artifact": { "path": "/abs/media.ogg", "mimeType": "audio/ogg" },\n    "args": {}\n  }\n\nSupported upload formats include flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, and webm.\n\nConfig at ${getToolConfigPath(toolName)}:\n  OPENAI_API_KEY\n  MODEL\n`);
 }
 
 async function run(requestFile) {
@@ -32,7 +79,7 @@ async function run(requestFile) {
   await stat(artifact.path);
   const form = new FormData();
   const data = await readFile(artifact.path);
-  form.append("file", new Blob([data]), path.basename(artifact.path));
+  form.append("file", new Blob([data], { type: baseMimeType(artifact.mimeType) || "application/octet-stream" }), uploadFileNameForArtifact(artifact));
   form.append("model", config.MODEL);
 
   const response = await fetch("https://api.openai.com/v1/audio/transcriptions", {

package/tools/openai-transcribe/tool.manifest.json

@@ -2,7 +2,24 @@
   "name": "openai-transcribe",
   "description": "Transcribe audio files and video audio tracks with OpenAI audio transcription API.",
   "entry": "index.js",
-  "input": ["audio/ogg", "audio/mpeg", "audio/wav", "audio/mp4", "video/mp4"],
+  "input": [
+    "audio/aac",
+    "audio/flac",
+    "audio/m4a",
+    "audio/mp3",
+    "audio/mp4",
+    "audio/mpeg",
+    "audio/mpga",
+    "audio/ogg",
+    "audio/opus",
+    "audio/wav",
+    "audio/wave",
+    "audio/webm",
+    "audio/x-m4a",
+    "audio/x-wav",
+    "video/mp4",
+    "video/webm"
+  ],
   "output": ["text/plain"],
   "configSchema": {
     "OPENAI_API_KEY": {