arisa 4.3.5 → 5.1.2

package/src/core/tools/tool-usage-store.js

@@ -0,0 +1,59 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getChatToolUsageFile } from "../../runtime/paths.js";
+
+function emptyUsage() {
+  return { version: 1, tools: {} };
+}
+
+async function readUsage(file) {
+  try {
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    return parsed?.version === 1 && parsed.tools && typeof parsed.tools === "object"
+      ? parsed
+      : emptyUsage();
+  } catch (error) {
+    if (error?.code === "ENOENT") return emptyUsage();
+    throw error;
+  }
+}
+
+async function writeUsage(file, usage) {
+  await mkdir(path.dirname(file), { recursive: true });
+  const temporary = `${file}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(usage, null, 2)}\n`, "utf8");
+  await rename(temporary, file);
+}
+
+export class ToolUsageStore {
+  constructor({ resolveFile = getChatToolUsageFile } = {}) {
+    this.resolveFile = resolveFile;
+    this.queues = new Map();
+  }
+
+  async record(chatId, toolName) {
+    if (chatId == null || chatId === "") return;
+    const key = String(chatId);
+    const previous = this.queues.get(key) || Promise.resolve();
+    const current = previous.catch(() => {}).then(async () => {
+      const file = this.resolveFile(chatId);
+      const usage = await readUsage(file);
+      const count = Number(usage.tools[toolName]?.count) || 0;
+      usage.tools[toolName] = { count: count + 1 };
+      await writeUsage(file, usage);
+    });
+    this.queues.set(key, current);
+    try {
+      await current;
+    } finally {
+      if (this.queues.get(key) === current) this.queues.delete(key);
+    }
+  }
+
+  async counts(chatId) {
+    if (chatId == null || chatId === "") return {};
+    await (this.queues.get(String(chatId)) || Promise.resolve()).catch(() => {});
+    const usage = await readUsage(this.resolveFile(chatId));
+    return Object.fromEntries(Object.entries(usage.tools).map(([name, value]) => [name, Number(value?.count) || 0]));
+  }
+}

package/src/index.js

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 
 import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
-import { createApp } from "./runtime/create-app.js";
+import { applyRuntimeOverrides, createApp } from "./runtime/create-app.js";
+import { loadConfig } from "./core/config/config-store.js";
 import { createLogger } from "./runtime/logger.js";
-import { getServiceStatus, registerServiceProcess, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
+import { getServiceStatus, handoffServiceRestart, registerServiceProcess, restartService, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
 import { flushArisaHome } from "./runtime/flush.js";
+import { readPackageVersion, showServiceLogs } from "./runtime/log-viewer.js";
 import { arisaPackageDir } from "./runtime/paths.js";
 
 process.env.ARISA_PACKAGE_DIR = arisaPackageDir;
@@ -69,17 +71,18 @@ function toNestedOverrides(nestedFlags) {
 
 function toServiceRunnerArgs(nestedFlags) {
   const args = [];
-  const serviceSafePiFlags = [
+  const serviceSafeAgentFlags = [
     "pi.provider",
     "pi.model",
     "pi.workspaceDir",
     "pi.tools",
     "pi.excludeTools",
     "pi.shellPath",
-    "pi.shellTimeoutMs"
+    "pi.shellTimeoutMs",
+    "pi.speed"
   ];
 
-  for (const flag of serviceSafePiFlags) {
+  for (const flag of serviceSafeAgentFlags) {
     if (nestedFlags[flag]) {
       args.push(`--${flag}`, nestedFlags[flag]);
     }
@@ -111,12 +114,21 @@ process.once("SIGINT", () => {
 });
 
 async function startRuntimeApp() {
-  const app = await createApp({ logger, runtimeOverrides });
+  const app = await createApp({
+    logger,
+    runtimeOverrides,
+    requestRestart: () => handoffServiceRestart({
+      verbose,
+      cliArgs: toServiceRunnerArgs(cli.nestedFlags)
+    })
+  });
   activeApp = app;
   await app.start();
 }
 
 async function startBackgroundService() {
+  const persistedConfig = await loadConfig();
+  applyRuntimeOverrides(persistedConfig, runtimeOverrides);
   const result = await startService({ verbose, cliArgs: toServiceRunnerArgs(cli.nestedFlags) });
   if (!result.ok) {
     console.log(`Arisa is already running in background (pid ${result.pid}).`);
@@ -127,6 +139,31 @@ async function startBackgroundService() {
   return result;
 }
 
+async function restartBackgroundService() {
+  const persistedConfig = await loadConfig();
+  applyRuntimeOverrides(persistedConfig, runtimeOverrides);
+  const result = await restartService({
+    verbose,
+    cliArgs: toServiceRunnerArgs(cli.nestedFlags),
+    shutdownTimeoutMs: persistedConfig.service.shutdownTimeoutMs,
+    shutdownPollIntervalMs: persistedConfig.service.shutdownPollIntervalMs
+  });
+  if (!result.ok) {
+    if (result.reason === "already-running") {
+      console.log(`Arisa could not be restarted because another instance is running (pid ${result.pid}).`);
+      return result;
+    }
+    throw new Error(`Arisa could not be restarted: ${result.reason || "unknown service error"}`);
+  }
+  if (result.wasRunning) {
+    console.log(`Arisa restarted in background (pid ${result.pid}; previous pid ${result.previousPid}).`);
+  } else {
+    console.log(`Arisa started in background (pid ${result.pid}); it was not running.`);
+  }
+  console.log(`Log file: ${result.logFile}`);
+  return result;
+}
+
 async function runForeground() {
   const hasRuntimePiOverrides = Boolean(
     runtimeOverrides?.pi?.model
@@ -197,6 +234,16 @@ async function main() {
     return;
   }
 
+  if (command === "restart") {
+    const bootstrapResult = await bootstrapIfNeeded({ force: forceBootstrap });
+    if (bootstrapResult.configCreated && bootstrapResult.viaTelegram && !bootstrapResult.startInBackground) {
+      console.log("Config saved. Arisa was not started in background.");
+      return;
+    }
+    await restartBackgroundService();
+    return;
+  }
+
   if (command === "status") {
     const status = await getServiceStatus();
     if (!status.running) {
@@ -207,6 +254,14 @@ async function main() {
     return;
   }
 
+  if (command === "log") {
+    await showServiceLogs({
+      version: await readPackageVersion(),
+      follow: !cli.flags["no-follow"]
+    });
+    return;
+  }
+
   if (command === "flush") {
     const status = await getServiceStatus();
     if (status.running) {

package/src/runtime/arisa-capabilities.js

@@ -41,10 +41,35 @@ function normalizeLimit(limit) {
   return Math.min(value, 100);
 }
 
-export function createArisaCapabilities({ artifactStore, taskStore, agentManager } = {}) {
+export function createArisaCapabilities({ artifactStore, taskStore, toolRegistry, agentManager } = {}) {
   async function dispatch({ method, toolName, chatId = null, params = {} } = {}) {
     const scopedToolName = requireToolName(toolName);
 
+    if (method === "tools.list") {
+      await toolRegistry.load();
+      return toolRegistry.listWithRuntime(chatId);
+    }
+
+    if (method === "tools.help") {
+      await toolRegistry.load();
+      return toolRegistry.help(requireString(params.name, "name"));
+    }
+
+    if (method === "tools.skills") {
+      await toolRegistry.load();
+      return toolRegistry.resolveSkills(requireString(params.name, "name"));
+    }
+
+    if (method === "tools.setConfig") {
+      await toolRegistry.load();
+      return toolRegistry.setConfig(
+        requireString(params.name, "name"),
+        requireString(params.field, "field"),
+        requireString(params.value, "value"),
+        requireChatId(chatId, method)
+      );
+    }
+
     if (method === "tools.run") {
       if (!agentManager?.runTool) {
         throw new Error("tools.run requires agentManager");
@@ -90,6 +115,20 @@ export function createArisaCapabilities({ artifactStore, taskStore, agentManager
       return artifactStore.forChat(scopedChatId).get(requireString(params.artifactId, "artifactId"));
     }
 
+    if (method === "artifacts.deliver") {
+      const scopedChatId = requireChatId(chatId, method);
+      const artifactId = requireString(params.artifactId, "artifactId");
+      const artifact = await artifactStore.forChat(scopedChatId).get(artifactId);
+      if (!artifact?.path) throw new Error(`Artifact not found or has no file: ${artifactId}`);
+      if (!agentManager?.deliverArtifact) throw new Error("artifact delivery is unavailable");
+      return agentManager.deliverArtifact({
+        chatId: scopedChatId,
+        artifact,
+        caption: params.caption,
+        method: params.method
+      });
+    }
+
     if (method === "tasks.add") {
       const scopedChatId = requireChatId(chatId, method);
       return taskStore.add(params.task || {}, {
@@ -118,6 +157,11 @@ export function createArisaCapabilities({ artifactStore, taskStore, agentManager
       return taskStore.cancel(taskId);
     }
 
+    if (method === "tasks.cancelAll") {
+      const scopedChatId = requireChatId(chatId, method);
+      return taskStore.cancelAll({ chatId: scopedChatId });
+    }
+
     if (method === "agent.enqueueEvent") {
       const scopedChatId = requireChatId(chatId, method);
       return taskStore.add({

package/src/runtime/bootstrap.js

@@ -7,6 +7,7 @@ import { Bot } from "grammy";
 import { createPiOAuthLogin } from "../core/agent/pi-auth-login.js";
 import { createPiRuntime, formatPiModelOption, hasProviderAuth, listPiProviders, listProviderModels, supportsProviderOAuth } from "../core/agent/pi-runtime.js";
 import { applyConfigDefaults, telegramConfigDefaults } from "../core/config/config-defaults.js";
+import { prepareConfigForSave } from "../core/config/config-store.js";
 import { buildDeviceCodeTelegramMessage } from "../transport/telegram/device-code-message.js";
 import { buildPagedInlineKeyboard } from "../transport/telegram/paged-inline-keyboard.js";
 import { configFile, ensureArisaHome } from "./paths.js";
@@ -29,7 +30,7 @@ async function exists(file) {
   }
 }
 
-function buildConfig({ telegramApiKey, telegramMaxChatIds, authorizedChatIds = [], chatMeta = {}, provider, model, piApiKey }) {
+export function buildConfig({ telegramApiKey, telegramMaxChatIds, authorizedChatIds = [], chatMeta = {}, provider, model, piApiKey }) {
   return applyConfigDefaults({
     telegram: {
       token: telegramApiKey,
@@ -602,7 +603,7 @@ export async function bootstrapIfNeeded({ force = false } = {}) {
       result = await collectCliBootstrapChoices({ telegramApiKey, rl, ask });
     }
 
-    await writeFile(configFile, `${JSON.stringify(result.config, null, 2)}\n`, "utf8");
+    await writeFile(configFile, `${JSON.stringify(prepareConfigForSave(result.config), null, 2)}\n`, "utf8");
     console.log(`\nConfig saved to ${configFile}\n`);
     return {
       configCreated: true,

package/src/runtime/create-app.js

@@ -8,6 +8,10 @@ import { createTelegramBot } from "../transport/telegram/bot.js";
 import { createToolProcessSupervisor } from "./tool-process-supervisor.js";
 import { createArisaCapabilities } from "./arisa-capabilities.js";
 import { createIpcServer } from "./ipc/ipc-server.js";
+import { getAgentConfig } from "../core/agent/model-selection.js";
+import { normalizeModelSpeed } from "../core/agent/model-speed.js";
+import { runDoctor } from "./doctor.js";
+import { checkForUpdates, formatUpdateReport } from "./update-manager.js";
 
 function normalizeString(value) {
   const text = String(value ?? "").trim();
@@ -51,10 +55,14 @@ function splitModelOverride(modelOverride) {
 }
 
 export function applyRuntimeOverrides(config, runtimeOverrides) {
+  const unsupportedNamespaces = Object.keys(runtimeOverrides || {}).filter((name) => name !== "pi");
+  if (unsupportedNamespaces.length) {
+    throw new Error(`Unsupported runtime override namespace: ${unsupportedNamespaces.join(", ")}`);
+  }
   const piRuntimeOverrides = runtimeOverrides?.pi || {};
   const pi = {};
-  const providerOverride = normalizeString(runtimeOverrides?.pi?.provider);
-  const modelOverride = normalizeString(runtimeOverrides?.pi?.model);
+  const providerOverride = normalizeString(piRuntimeOverrides.provider);
+  const modelOverride = normalizeString(piRuntimeOverrides.model);
 
   if (providerOverride || modelOverride) {
     const splitOverride = modelOverride ? splitModelOverride(modelOverride) : null;
@@ -77,6 +85,7 @@ export function applyRuntimeOverrides(config, runtimeOverrides) {
 
   const shellTimeoutMs = normalizePositiveInteger(piRuntimeOverrides.shellTimeoutMs);
   if (shellTimeoutMs) pi.shellTimeoutMs = shellTimeoutMs;
+  if (piRuntimeOverrides.speed !== undefined) pi.speed = normalizeModelSpeed(piRuntimeOverrides.speed);
 
   if (!Object.keys(pi).length) return config;
 
@@ -89,32 +98,56 @@ export function applyRuntimeOverrides(config, runtimeOverrides) {
   };
 }
 
-export async function createApp({ logger, runtimeOverrides } = {}) {
+export async function createApp({ logger, runtimeOverrides, requestRestart } = {}) {
+  if (typeof requestRestart !== "function") {
+    throw new Error("createApp requires a service restart handoff");
+  }
   logger?.log("app", "loading config");
   const persistedConfig = await loadConfig();
-  const config = applyRuntimeOverrides(persistedConfig, runtimeOverrides);
-  if (config.pi.provider !== persistedConfig.pi.provider || config.pi.model !== persistedConfig.pi.model) {
-    logger?.log("app", `applying runtime model override: ${persistedConfig.pi.provider}/${persistedConfig.pi.model} -> ${config.pi.provider}/${config.pi.model}`);
+  const overriddenConfig = applyRuntimeOverrides(persistedConfig, runtimeOverrides);
+  const config = overriddenConfig;
+  const activeConfig = getAgentConfig(config);
+  const persistedActiveConfig = getAgentConfig(persistedConfig);
+  if (activeConfig.provider !== persistedActiveConfig.provider || activeConfig.model !== persistedActiveConfig.model) {
+    logger?.log("app", `applying runtime model override: ${persistedActiveConfig.provider}/${persistedActiveConfig.model} -> ${activeConfig.provider}/${activeConfig.model}`);
   }
 
   const artifactStore = new ArtifactStore();
-  const toolProcessSupervisor = createToolProcessSupervisor({ logger, policy: config.daemons });
   const toolRegistry = new ToolRegistry({ logger });
+  const toolProcessSupervisor = createToolProcessSupervisor({ logger, policy: config.daemons, toolRegistry });
   const taskStore = new TaskStore();
   await toolRegistry.load();
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);
 
   const agentManager = new AgentManager({ config, artifactStore, toolRegistry, taskStore, logger });
-  const arisaCapabilities = createArisaCapabilities({ artifactStore, taskStore, agentManager });
+  const arisaCapabilities = createArisaCapabilities({ artifactStore, taskStore, toolRegistry, agentManager });
   const ipcServer = createIpcServer({ capabilities: arisaCapabilities, logger });
-  const bot = await createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger });
+  const bot = await createTelegramBot({
+    config,
+    artifactStore,
+    toolRegistry,
+    taskStore,
+    agentManager,
+    saveConfig,
+    updateConfig,
+    doctor: () => runDoctor({
+      agentManager,
+      toolProcessSupervisor,
+      daemonPolicy: config.daemons,
+      doctorPolicy: config.doctor,
+      logger
+    }),
+    checkUpdates: async (chatId) => formatUpdateReport(await checkForUpdates({ chatId, toolRegistry })),
+    requestRestart,
+    logger
+  });
 
   return {
     async start() {
-      logger?.log("app", `validating Pi model ${config.pi.provider}/${config.pi.model}`);
+      logger?.log("app", `validating Pi model ${activeConfig.provider}/${activeConfig.model}`);
       let skipAgentStartupPrompts = false;
       try {
-        await agentManager.validatePiAgent();
+        await agentManager.validateAgent();
       } catch (error) {
         const issue = getPiAuthIssue(error);
         if (!issue) {
@@ -129,6 +162,10 @@ export async function createApp({ logger, runtimeOverrides } = {}) {
       try {
         await ipcServer.start();
         ipcStarted = true;
+        const recoveredTasks = await taskStore.recoverInterrupted();
+        if (recoveredTasks.length) {
+          logger?.log("tasks", `recovered ${recoveredTasks.length} interrupted task(s)`);
+        }
         await toolProcessSupervisor.start();
         supervisorStarted = true;
         logger?.log("app", "starting Telegram bot");
@@ -142,6 +179,7 @@ export async function createApp({ logger, runtimeOverrides } = {}) {
 
     async stop() {
       await bot.stop?.();
+      await agentManager.close();
       await toolProcessSupervisor.stop();
       await ipcServer.stop();
     }