arisa 3.0.14 → 3.1.2

package/src/core/tasks/task-store.js

@@ -56,6 +56,10 @@ export class TaskStore {
     if (!this.tasks) this.tasks = await loadTasksFile();
   }
 
+  async reload() {
+    this.tasks = await loadTasksFile();
+  }
+
   async save() {
     await saveTasksFile(this.tasks || []);
   }
@@ -77,7 +81,7 @@ export class TaskStore {
   }
 
   async claimDue(limit = 10) {
-    await this.init();
+    await this.reload();
     const now = Date.now();
     const due = [];
 
@@ -126,7 +130,7 @@ export class TaskStore {
   }
 
   async list(filter = {}) {
-    await this.init();
+    await this.reload();
     return this.tasks.filter((task) => {
       if (filter.chatId && task.payload?.chatId !== filter.chatId) return false;
       if (filter.status && task.status !== filter.status) return false;
@@ -136,12 +140,12 @@ export class TaskStore {
   }
 
   async get(taskId) {
-    await this.init();
+    await this.reload();
     return this.tasks.find((item) => item.id === taskId) || null;
   }
 
   async cancel(taskId) {
-    await this.init();
+    await this.reload();
     const index = this.tasks.findIndex((item) => item.id === taskId);
     if (index === -1) return null;
     const [task] = this.tasks.splice(index, 1);
@@ -150,7 +154,7 @@ export class TaskStore {
   }
 
   async cancelAll(filter = {}) {
-    await this.init();
+    await this.reload();
     const removed = [];
     this.tasks = this.tasks.filter((task) => {
       if (filter.chatId && task.payload?.chatId !== filter.chatId) return true;

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

@@ -0,0 +1,167 @@
+import crypto from "node:crypto";
+import { spawn } from "node:child_process";
+import { openSync } from "node:fs";
+import { mkdir, readFile, readdir, rename, rm, unlink, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { stateDir } from "../../runtime/paths.js";
+
+export function daemonPaths(toolName) {
+  const root = path.join(stateDir, toolName);
+  return {
+    root,
+    commandsDir: path.join(root, "commands"),
+    pidFile: path.join(root, "daemon.pid"),
+    statusFile: path.join(root, "status.json"),
+    logFile: path.join(root, "daemon.log")
+  };
+}
+
+export async function readJson(file, fallback = {}) {
+  try { return JSON.parse(await readFile(file, "utf8")); } catch { return fallback; }
+}
+
+export async function writeJson(file, value) {
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+export function isProcessAlive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+export function createDaemonRuntime({ toolName, entryPath, beforeStart = null }) {
+  const paths = daemonPaths(toolName);
+
+  async function ensure() {
+    await mkdir(paths.commandsDir, { recursive: true });
+  }
+
+  function jobPaths(id) {
+    return {
+      request: path.join(paths.commandsDir, `${id}.request.json`),
+      processing: path.join(paths.commandsDir, `${id}.processing.json`),
+      result: path.join(paths.commandsDir, `${id}.result.json`)
+    };
+  }
+
+  async function getPid() {
+    return (await readJson(paths.pidFile, {})).pid;
+  }
+
+  async function writeStatus(patch) {
+    const current = await readJson(paths.statusFile, {});
+    await writeJson(paths.statusFile, { ...current, ...patch, updatedAt: new Date().toISOString() });
+  }
+
+  async function clearJobs() {
+    await rm(paths.commandsDir, { recursive: true, force: true });
+    await mkdir(paths.commandsDir, { recursive: true });
+  }
+
+  async function start() {
+    await ensure();
+    const pid = await getPid();
+    if (isProcessAlive(pid)) return pid;
+
+    await clearJobs();
+    if (beforeStart) await beforeStart();
+    const out = openSync(paths.logFile, "a");
+    const child = spawn(process.execPath, [entryPath, "daemon"], {
+      detached: true,
+      stdio: ["ignore", out, out],
+      env: process.env
+    });
+    child.unref();
+    await writeJson(paths.pidFile, { pid: child.pid, startedAt: new Date().toISOString() });
+    return child.pid;
+  }
+
+  async function stop() {
+    const pid = await getPid();
+    if (isProcessAlive(pid)) process.kill(pid, "SIGTERM");
+    await rm(paths.pidFile, { force: true });
+  }
+
+  async function waitReady({ timeoutMs = 120000, readyStates = ["ready"] } = {}) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const status = await readJson(paths.statusFile, {});
+      const pid = await getPid();
+      if (readyStates.includes(status.state) && isProcessAlive(pid)) return status;
+      if (status.state === "error") throw new Error(status.message || `${toolName} daemon failed`);
+      await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    throw new Error(`${toolName} daemon was not ready after ${timeoutMs}ms`);
+  }
+
+  async function submit(payload, { timeoutMs = 180000, readyTimeoutMs = 120000 } = {}) {
+    await start();
+    await waitReady({ timeoutMs: readyTimeoutMs });
+    const id = crypto.randomUUID();
+    const files = jobPaths(id);
+    await writeJson(files.request, { id, ...payload });
+
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const result = await readJson(files.result, null);
+      if (result) {
+        await unlink(files.result).catch(() => {});
+        if (!result.ok) throw new Error(result.error || `${toolName} job failed`);
+        return result.output || {};
+      }
+      await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    throw new Error(`${toolName} job timed out after ${timeoutMs}ms`);
+  }
+
+  async function claimNext() {
+    await ensure();
+    const files = (await readdir(paths.commandsDir)).filter((file) => file.endsWith(".request.json"));
+    for (const file of files) {
+      const id = file.replace(/\.request\.json$/, "");
+      const item = jobPaths(id);
+      try {
+        await rename(item.request, item.processing);
+        return { id, ...item, payload: await readJson(item.processing, null) };
+      } catch {}
+    }
+    return null;
+  }
+
+  async function complete(job, output) {
+    await writeJson(job.result, { ok: true, output });
+    await unlink(job.processing).catch(() => {});
+  }
+
+  async function fail(job, error) {
+    await writeJson(job.result, { ok: false, error: error?.message || String(error) });
+    await unlink(job.processing).catch(() => {});
+  }
+
+  async function workLoop({ processJob, idleTimeoutMs = 0, intervalMs = 250 }) {
+    let lastActivity = Date.now();
+    setInterval(async () => {
+      try {
+        const job = await claimNext();
+        if (job) {
+          lastActivity = Date.now();
+          try {
+            await complete(job, await processJob(job.payload));
+          } catch (error) {
+            await fail(job, error);
+          }
+          lastActivity = Date.now();
+        }
+        if (idleTimeoutMs > 0 && Date.now() - lastActivity > idleTimeoutMs) {
+          await writeStatus({ state: "stopped", message: "Idle timeout reached" });
+          process.exit(0);
+        }
+      } catch (error) {
+        await writeStatus({ state: "error", message: error?.message || String(error) });
+      }
+    }, intervalMs);
+  }
+
+  return { paths, ensure, getPid, writeStatus, start, stop, waitReady, submit, workLoop };
+}

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

@@ -1,6 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { getToolConfigPath } from "../../runtime/paths.js";
+import { getToolConfigPath, getChatToolConfigPath } from "../../runtime/paths.js";
 
 export function parseConfigModule(source) {
   const normalized = source.replace(/^export\s+default/, "return");
@@ -21,14 +21,22 @@ export async function readConfigModule(filePath, fallback = {}) {
   }
 }
 
-export async function loadToolConfig(toolName, defaults = {}) {
-  const configPath = getToolConfigPath(toolName);
-  const stored = await readConfigModule(configPath, {});
-  return { ...defaults, ...stored };
+export async function loadToolConfig(toolName, defaults = {}, chatId = null) {
+  const globalPath = getToolConfigPath(toolName);
+  const globalStored = await readConfigModule(globalPath, {});
+  const merged = { ...defaults, ...globalStored };
+
+  if (chatId == null) return merged;
+
+  const chatPath = getChatToolConfigPath(chatId, toolName);
+  const chatStored = await readConfigModule(chatPath, {});
+  return { ...merged, ...chatStored };
 }
 
-export async function writeToolConfig(toolName, config) {
-  const configPath = getToolConfigPath(toolName);
+export async function writeToolConfig(toolName, config, chatId = null) {
+  const configPath = chatId != null
+    ? getChatToolConfigPath(chatId, toolName)
+    : getToolConfigPath(toolName);
   await mkdir(path.dirname(configPath), { recursive: true });
   await writeFile(configPath, serializeConfigModule(config), "utf8");
   return configPath;

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

@@ -2,7 +2,7 @@ import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { getToolConfigPath, getToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
+import { getToolConfigPath, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
 import { loadToolConfig, parseConfigModule, writeToolConfig } from "./tool-config.js";
 import { normalizeToolResult } from "./tool-result.js";
 
@@ -92,22 +92,33 @@ export class ToolRegistry {
     return result.stdout || result.stderr;
   }
 
-  async setConfig(name, field, value) {
+  async resolveConfigForChat(name, chatId) {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
-    const config = { ...(tool.config || {}) };
-    config[field] = value;
-    const configPath = await writeToolConfig(name, config);
-    tool.config = config;
-    tool.configPath = configPath;
+    if (chatId == null) return tool.config || {};
+    return loadToolConfig(name, tool.defaults || {}, chatId);
+  }
+
+  async setConfig(name, field, value, chatId = null) {
+    const tool = this.get(name);
+    if (!tool) throw new Error(`Tool not found: ${name}`);
+    const current = chatId != null
+      ? await this.resolveConfigForChat(name, chatId)
+      : { ...(tool.config || {}) };
+    current[field] = value;
+    const configPath = await writeToolConfig(name, current, chatId);
+    if (chatId == null) {
+      tool.config = current;
+      tool.configPath = configPath;
+    }
     return { ok: true, tool: name, field, configPath };
   }
 
-  async run({ name, request }) {
+  async run({ name, request, chatId = null }) {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
     this.logger?.log("tools", `running ${name}`);
-    const tmpDir = getToolTmpDir(name);
+    const tmpDir = chatId != null ? getChatToolTmpDir(chatId, name) : getToolTmpDir(name);
     await mkdir(tmpDir, { recursive: true });
     const requestFile = path.join(tmpDir, `.request-${Date.now()}.json`);
     await writeFile(requestFile, `${JSON.stringify(request, null, 2)}\n`, "utf8");

package/src/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import { createServer } from "node:http";
 import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
 import { createApp } from "./runtime/create-app.js";
 import { createLogger } from "./runtime/logger.js";
@@ -8,25 +9,117 @@ import { flushArisaHome } from "./runtime/flush.js";
 import { installPiPackage, removePiPackage } from "./runtime/pi-package-manager.js";
 
 const args = process.argv.slice(2);
-const command = args.find((arg) => !arg.startsWith("--")) || "run";
-const forceBootstrap = args.includes("--bootstrap");
-const verbose = args.includes("--verbose");
-const serviceRunner = args.includes("--service-runner");
+const cli = parseCliArgs(args);
+const command = cli.positionals[0] || "run";
+const forceBootstrap = Boolean(cli.flags.bootstrap);
+const verbose = Boolean(cli.flags.verbose);
+const serviceRunner = Boolean(cli.flags["service-runner"]);
+const bootstrapOverrides = toBootstrapOverrides(cli.nestedFlags);
+const runtimeOverrides = toRuntimeOverrides(cli.nestedFlags);
 const logger = createLogger({ verbose });
 
+const httpPort = Number(process.env.PORT);
+let httpRequestHandler = null;
+
+function setHttpRequestHandler(handler) {
+  httpRequestHandler = handler;
+}
+
+if (httpPort && bootstrapOverrides.telegram) {
+  createServer((req, res) => {
+    if (httpRequestHandler) return httpRequestHandler(req, res);
+    res.writeHead(200, { "Content-Type": "text/plain" });
+    res.end("ok");
+  }).listen(httpPort)
+    .on("listening", () => logger.log("http", `health server on port ${httpPort}`));
+}
+
+function parseCliArgs(rawArgs) {
+  const flags = {};
+  const nestedFlags = {};
+  const positionals = [];
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const token = rawArgs[index];
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+
+    const flagName = token.slice(2);
+    if (!flagName) continue;
+    if (flagName.includes(".")) {
+      const next = rawArgs[index + 1];
+      const hasValue = typeof next === "string" && !next.startsWith("--");
+      if (hasValue) {
+        nestedFlags[flagName] = next;
+        index += 1;
+      }
+      continue;
+    }
+
+    flags[flagName] = true;
+  }
+
+  return { flags, nestedFlags, positionals };
+}
+
+function toBootstrapOverrides(nestedFlags) {
+  const overrides = {};
+  for (const [flatKey, value] of Object.entries(nestedFlags)) {
+    const parts = flatKey.split(".");
+    let cursor = overrides;
+    for (let index = 0; index < parts.length - 1; index += 1) {
+      const key = parts[index];
+      if (!cursor[key] || typeof cursor[key] !== "object") {
+        cursor[key] = {};
+      }
+      cursor = cursor[key];
+    }
+    cursor[parts[parts.length - 1]] = value;
+  }
+  return overrides;
+}
+
+function toRuntimeOverrides(nestedFlags) {
+  return toBootstrapOverrides(nestedFlags);
+}
+
+function toServiceRunnerArgs(nestedFlags) {
+  const args = [];
+  if (nestedFlags["pi.model"]) {
+    args.push("--pi.model", nestedFlags["pi.model"]);
+  }
+  return args;
+}
+
+const bootstrapHttpOptions = httpPort ? { httpPort, setHttpRequestHandler } : {};
+const webhookUrl = bootstrapOverrides.webhook?.url || "";
+const appHttpOptions = httpPort ? { webhookUrl, setHttpRequestHandler } : {};
+
 async function runForeground() {
+  const hasRuntimePiOverrides = Boolean(
+    runtimeOverrides?.pi?.model
+    || runtimeOverrides?.pi?.provider
+    || runtimeOverrides?.pi?.apiKey
+  );
   logger.log("app", `starting${verbose ? " in verbose mode" : ""}`);
-  await bootstrapIfNeeded({ force: forceBootstrap });
+  await bootstrapIfNeeded({ force: forceBootstrap, cliConfigOverrides: bootstrapOverrides, ...bootstrapHttpOptions });
   try {
-    const app = await createApp({ logger });
+    const app = await createApp({ logger, runtimeOverrides, ...appHttpOptions });
     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`);
+      if (hasRuntimePiOverrides) {
+        console.log("Skipping automatic bootstrap because Pi runtime overrides were provided.");
+        console.log("Keeping existing Telegram config. Run `arisa --bootstrap` manually if you want to update persisted auth/config.\n");
+        throw error;
+      }
       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({ logger });
+      await bootstrapIfNeeded({ force: true, cliConfigOverrides: bootstrapOverrides, ...bootstrapHttpOptions });
+      const app = await createApp({ logger, runtimeOverrides, ...appHttpOptions });
       await app.start();
       return;
     }
@@ -42,8 +135,8 @@ async function main() {
   }
 
   if (command === "start") {
-    await bootstrapIfNeeded({ force: forceBootstrap });
-    const result = await startService({ verbose });
+    await bootstrapIfNeeded({ force: forceBootstrap, cliConfigOverrides: bootstrapOverrides, ...bootstrapHttpOptions });
+    const result = await startService({ verbose, cliArgs: toServiceRunnerArgs(cli.nestedFlags) });
     if (!result.ok) {
       console.log(`Arisa is already running in background (pid ${result.pid}).`);
       return;
@@ -85,7 +178,7 @@ async function main() {
   }
 
   if (command === "install") {
-    const source = args.filter((arg) => !arg.startsWith("--")).slice(1)[0];
+    const source = cli.positionals[1];
     if (!source) {
       console.log("Usage: arisa install <pi-package-source>");
       return;
@@ -96,7 +189,7 @@ async function main() {
   }
 
   if (command === "remove") {
-    const source = args.filter((arg) => !arg.startsWith("--")).slice(1)[0];
+    const source = cli.positionals[1];
     if (!source) {
       console.log("Usage: arisa remove <pi-package-source>");
       return;