arisa 4.0.18 → 4.0.22

package/AGENTS.md

@@ -8,6 +8,12 @@
 - Tools are isolated and each one has its own manifest, entrypoint, and config defaults.
 - No tools ship with the core. All installed tools live under `~/.arisa/tools/<toolName>`; the install directory of Arisa (your working directory) contains only the core. Never create or install tools inside the install directory.
 
+## Core modification policy
+Modifying the Arisa core is the last resort, never the default. All work must be done in tools.
+- Always solve the request by creating or editing a tool under `~/.arisa/tools/<toolName>`.
+- Treat changing core code as the final option, only after confirming the capability genuinely cannot be delivered through the tool architecture.
+- Never modify the core on your own initiative. Always consult the user first, explaining why a core change is unavoidable, and wait for explicit approval before touching core code.
+
 ## Runtime directory rules
 Do not build runtime paths by hand. Use `src/runtime/paths.js`:
 - `getToolDir(toolName)`: installed user tool package only; no runtime data here.
@@ -33,7 +39,7 @@ Each tool declares in `tool.manifest.json`:
 - `skillHints`: optional skills to apply when using or editing the tool
 
 ## Tool-to-Arisa IPC
-Arisa does not mount tool-provided web routes in core. If a tool needs to expose a web UI or HTTP endpoint, the tool owns that server, usually through the shared daemon runtime. The tool's server handles its own requests and uses Arisa IPC when it needs artifacts, tasks, agent events, or runtime paths.
+Arisa does not mount tool-provided web routes in core. If a tool needs to expose a web UI or HTTP endpoint, the tool owns that server, usually through the shared daemon runtime. The tool's server handles its own requests and uses Arisa IPC when it needs to run a registered tool, create/read artifacts, manage tasks, enqueue agent events, or resolve runtime paths.
 
 Installed tools can import the IPC client through `ARISA_PACKAGE_DIR`:
 
@@ -48,7 +54,17 @@ const arisa = createArisaClient({ toolName: "example-tool", chatId });
 await arisa.artifacts.createText({ text: "hello" });
 ```
 
-The IPC channel is a local socket under `~/.arisa/state`. Every request must include `toolName`; chat-scoped capabilities also require `chatId`. Exposed capabilities are explicit: artifacts (`createText`, `listRecent`, `get`), tasks (`add`, `list`, `cancel`), agent events (`enqueueEvent`), and runtime paths (`getChatToolStateDir`, `getToolStateDir`, `getChatToolTmpDir`, `getToolTmpDir`, `getChatArtifactsDir`). Do not add raw access to `agentManager`, `taskStore`, `artifactStore`, or `toolRegistry`.
+For tool-owned web UI request/response flows, call another registered tool through IPC instead of adding core HTTP routes or proxies:
+
+```js
+const result = await arisa.tools.run({
+  name: "strudel-agent",
+  text: prompt,
+  args: { bpm, tags, currentCode }
+}, { timeoutMs: 120_000 });
+```
+
+The IPC channel is a local socket under `~/.arisa/state`. Every request must include `toolName`; chat-scoped capabilities also require `chatId`. Exposed capabilities are explicit: tools (`run`), artifacts (`createText`, `listRecent`, `get`), tasks (`add`, `list`, `cancel`), agent events (`enqueueEvent`), and runtime paths (`getChatToolStateDir`, `getToolStateDir`, `getChatToolTmpDir`, `getToolTmpDir`, `getChatArtifactsDir`). Do not add raw access to `agentManager`, `taskStore`, `artifactStore`, or `toolRegistry`.
 
 ## Conceptual pipe model
 There are two different moments where pipes can happen:

package/README.md

@@ -114,6 +114,7 @@ arisa start              # start in background
 arisa stop               # stop background service
 arisa status             # show background service status
 arisa flush              # remove ~/.arisa
+arisa --silent           # run without verbose logs
 ```
 
 Runtime model override (current process only):
@@ -138,32 +139,7 @@ On first run, Arisa will:
 6. validate that Pi Agent works
 7. only then start listening to Telegram
 
-### Non-interactive bootstrap (CLI overrides)
-
-You can skip the interactive questions by providing `--telegram.token` and optional overrides:
-
-```bash
-node src/index.js --telegram.token <token>
-```
-
-With this mode, Arisa creates `~/.arisa/state/config.json` without prompts and applies these defaults when not provided:
-
-- `pi.provider`: `openai-codex` when available, otherwise first provider from the current Pi provider list
-- `pi.model`: first model after bootstrap sorting (currently prioritizes `openai-codex/gpt-5.5`)
-- `telegram.maxChatIds`: `1`
-
-Supported overrides:
-
-```bash
-node src/index.js --telegram.token <token> --telegram.maxChatIds 3 --pi.provider openai-codex --pi.model gpt-5.5 --pi.apiKey <optional-provider-key>
-```
-
-Notes:
-
-- interactive bootstrap remains unchanged when no CLI overrides are provided
-- `--bootstrap` can be combined with overrides to regenerate config non-interactively
-- when `--pi.apiKey` is omitted and the provider supports OAuth, bootstrap can use a temporary auth relay if `PORT` is set; this relay is only for Pi login and is not a tool web route server
-- unknown `--pi.provider` or `--pi.model` values are ignored and replaced by safe defaults
+Arisa does not run a persistent HTTP health server or Telegram webhook; Telegram uses long polling.
 
 Telegram bot tokens can be created with:
 

package/package.json

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

package/src/core/tools/ipc-client.js

@@ -58,8 +58,9 @@ export function createArisaClient({ toolName, chatId = null, socketPath = proces
     throw new Error("toolName is required");
   }
 
-  const call = (method, params = {}) => requestIpc({
+  const call = (method, params = {}, options = {}) => requestIpc({
     socketPath,
+    timeoutMs: options.timeoutMs,
     request: {
       id: crypto.randomUUID(),
       method,
@@ -83,6 +84,9 @@ export function createArisaClient({ toolName, chatId = null, socketPath = proces
     agent: {
       enqueueEvent: (params) => call("agent.enqueueEvent", params)
     },
+    tools: {
+      run: (params, options) => call("tools.run", params, options)
+    },
     paths: {
       getChatToolStateDir: () => call("paths.getChatToolStateDir"),
       getToolStateDir: () => call("paths.getToolStateDir"),

package/src/index.js

@@ -1,14 +1,11 @@
 #!/usr/bin/env node
 
-import { createServer } from "node:http";
-import { execFile } from "node:child_process";
 import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
 import { createApp } from "./runtime/create-app.js";
 import { createLogger } from "./runtime/logger.js";
 import { getServiceStatus, registerServiceProcess, startService, stopService, unregisterServiceProcess } from "./runtime/service-manager.js";
 import { flushArisaHome } from "./runtime/flush.js";
 import { arisaPackageDir } from "./runtime/paths.js";
-import { parseProcessIds } from "./runtime/process-ids.js";
 
 process.env.ARISA_PACKAGE_DIR = arisaPackageDir;
 
@@ -16,136 +13,13 @@ const args = process.argv.slice(2);
 const cli = parseCliArgs(args);
 const command = cli.positionals[0] || "run";
 const forceBootstrap = Boolean(cli.flags.bootstrap);
-const verbose = Boolean(cli.flags.verbose);
+const verbose = !cli.flags.silent;
 const serviceRunner = Boolean(cli.flags["service-runner"]);
-const bootstrapOverrides = toBootstrapOverrides(cli.nestedFlags);
-const runtimeOverrides = toRuntimeOverrides(cli.nestedFlags);
+const runtimeOverrides = toNestedOverrides(cli.nestedFlags);
 const logger = createLogger({ verbose });
 let activeApp = null;
 let shuttingDown = false;
 
-const defaultHttpPort = 11970;
-const httpPort = Number(process.env.ARISA_HTTP_PORT || defaultHttpPort);
-const shouldStartHttpServer = Boolean(httpPort && !["stop", "status", "flush"].includes(command));
-let httpRequestHandler = null;
-let httpServerListening = false;
-let httpServer = null;
-
-function setHttpRequestHandler(handler) {
-  httpRequestHandler = handler;
-}
-
-const httpServerReady = shouldStartHttpServer
-  ? startHttpServer()
-  : Promise.resolve(false);
-
-async function runCommand(commandName, args = []) {
-  return new Promise((resolve) => {
-    execFile(commandName, args, (error, stdout = "") => {
-      resolve(error ? "" : stdout.trim());
-    });
-  });
-}
-
-async function getListeningPids(port) {
-  const lsofOutput = await runCommand("lsof", ["-tiTCP", `-sTCP:LISTEN`, `-iTCP:${port}`]);
-  if (lsofOutput) {
-    return parseProcessIds(lsofOutput);
-  }
-
-  const fuserOutput = await runCommand("fuser", ["-n", "tcp", String(port)]);
-  return parseProcessIds(fuserOutput);
-}
-
-async function getProcessCommand(pid) {
-  return runCommand("ps", ["-p", String(pid), "-o", "command="]);
-}
-
-function looksLikeArisaProcess(commandText) {
-  return /\barisa\b/.test(commandText) || /\/arisa\/src\/index\.js\b/i.test(commandText);
-}
-
-function isProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function waitForProcessExit(pid, timeoutMs = 3000) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!isProcessRunning(pid)) return true;
-    await new Promise((resolve) => setTimeout(resolve, 100));
-  }
-  return !isProcessRunning(pid);
-}
-
-async function stopStaleArisaListeners(port) {
-  const pids = await getListeningPids(port);
-  for (const pid of pids) {
-    if (pid === process.pid) continue;
-    const commandText = await getProcessCommand(pid);
-    if (!looksLikeArisaProcess(commandText)) {
-      logger.error("http", `port ${port} is already used by pid ${pid}; not killing non-Arisa process`);
-      continue;
-    }
-
-    logger.log("http", `stopping stale Arisa listener on port ${port} (pid ${pid})`);
-    try {
-      process.kill(pid, "SIGTERM");
-      if (!await waitForProcessExit(pid)) {
-        process.kill(pid, "SIGKILL");
-        await waitForProcessExit(pid, 1000);
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      logger.error("http", `failed to stop stale Arisa listener pid ${pid}: ${message}`);
-    }
-  }
-}
-
-async function startHttpServer() {
-  await stopStaleArisaListeners(httpPort);
-  return new Promise((resolve) => {
-    const server = createServer((req, res) => {
-      if (httpRequestHandler) return httpRequestHandler(req, res);
-      res.writeHead(200, { "Content-Type": "text/plain" });
-      res.end("ok");
-      return undefined;
-    });
-    httpServer = server;
-    server.on("error", (error) => {
-      const message = error instanceof Error ? error.message : String(error);
-      logger.error("http", `server failed on port ${httpPort}: ${message}`);
-      resolve(false);
-    });
-    server.listen(httpPort)
-      .on("listening", () => {
-        httpServerListening = true;
-        logger.log("http", `health server on port ${httpPort}`);
-        resolve(true);
-      });
-  });
-}
-
-async function getHttpOptions() {
-  await httpServerReady;
-  return httpServerListening ? { httpPort, setHttpRequestHandler } : {};
-}
-
-async function stopHttpServer() {
-  if (!httpServerListening || !httpServer) return;
-  await new Promise((resolve) => {
-    httpServer.close(() => resolve());
-  });
-  httpServer = null;
-  httpServerListening = false;
-  httpRequestHandler = null;
-}
-
 function parseCliArgs(rawArgs) {
   const flags = {};
   const nestedFlags = {};
@@ -176,7 +50,7 @@ function parseCliArgs(rawArgs) {
   return { flags, nestedFlags, positionals };
 }
 
-function toBootstrapOverrides(nestedFlags) {
+function toNestedOverrides(nestedFlags) {
   const overrides = {};
   for (const [flatKey, value] of Object.entries(nestedFlags)) {
     const parts = flatKey.split(".");
@@ -193,10 +67,6 @@ function toBootstrapOverrides(nestedFlags) {
   return overrides;
 }
 
-function toRuntimeOverrides(nestedFlags) {
-  return toBootstrapOverrides(nestedFlags);
-}
-
 function toServiceRunnerArgs(nestedFlags) {
   const args = [];
   if (nestedFlags["pi.model"]) {
@@ -205,14 +75,11 @@ function toServiceRunnerArgs(nestedFlags) {
   return args;
 }
 
-const webhookUrl = bootstrapOverrides.webhook?.url || "";
-
 async function shutdown(exitCode = 0) {
   if (shuttingDown) return;
   shuttingDown = true;
   try {
     await activeApp?.stop?.();
-    await stopHttpServer();
   } catch (error) {
     logger.error("app", `shutdown failed: ${error instanceof Error ? error.message : String(error)}`);
     exitCode = exitCode || 1;
@@ -231,8 +98,8 @@ process.once("SIGINT", () => {
   shutdown(0);
 });
 
-async function startRuntimeApp(httpOptions = {}) {
-  const app = await createApp({ logger, runtimeOverrides, webhookUrl, ...httpOptions });
+async function startRuntimeApp() {
+  const app = await createApp({ logger, runtimeOverrides });
   activeApp = app;
   await app.start();
 }
@@ -244,10 +111,9 @@ async function runForeground() {
     || runtimeOverrides?.pi?.apiKey
   );
   logger.log("app", `starting${verbose ? " in verbose mode" : ""}`);
-  const httpOptions = await getHttpOptions();
-  await bootstrapIfNeeded({ force: forceBootstrap, cliConfigOverrides: bootstrapOverrides, ...httpOptions });
+  await bootstrapIfNeeded({ force: forceBootstrap });
   try {
-    await startRuntimeApp(httpOptions);
+    await startRuntimeApp();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (message.includes("No auth found")) {
@@ -260,8 +126,8 @@ async function runForeground() {
         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, cliConfigOverrides: bootstrapOverrides, ...httpOptions });
-      await startRuntimeApp(httpOptions);
+      await bootstrapIfNeeded({ force: true });
+      await startRuntimeApp();
       return;
     }
     throw error;
@@ -276,9 +142,7 @@ async function main() {
   }
 
   if (command === "start") {
-    const httpOptions = await getHttpOptions();
-    await bootstrapIfNeeded({ force: forceBootstrap, cliConfigOverrides: bootstrapOverrides, ...httpOptions });
-    await stopHttpServer();
+    await bootstrapIfNeeded({ force: forceBootstrap });
     const result = await startService({ verbose, cliArgs: toServiceRunnerArgs(cli.nestedFlags) });
     if (!result.ok) {
       console.log(`Arisa is already running in background (pid ${result.pid}).`);

package/src/runtime/arisa-capabilities.js

@@ -27,16 +27,49 @@ function requireString(value, fieldName) {
   return value;
 }
 
+function normalizeArgs(args) {
+  if (args == null) return {};
+  if (typeof args !== "object" || Array.isArray(args)) {
+    throw new Error("args must be an object");
+  }
+  return args;
+}
+
 function normalizeLimit(limit) {
   const value = Number(limit);
   if (!Number.isInteger(value) || value <= 0) return 20;
   return Math.min(value, 100);
 }
 
-export function createArisaCapabilities({ artifactStore, taskStore } = {}) {
+export function createArisaCapabilities({ artifactStore, taskStore, agentManager } = {}) {
   async function dispatch({ method, toolName, chatId = null, params = {} } = {}) {
     const scopedToolName = requireToolName(toolName);
 
+    if (method === "tools.run") {
+      if (!agentManager?.runTool) {
+        throw new Error("tools.run requires agentManager");
+      }
+      const scopedChatId = requireChatId(chatId, method);
+      const targetToolName = requireString(params.name, "name");
+      const chatArtifactStore = artifactStore.forChat(scopedChatId);
+      const artifact = params.artifactId
+        ? await chatArtifactStore.get(requireString(params.artifactId, "artifactId"))
+        : null;
+      if (params.artifactId && !artifact) {
+        throw new Error(`Artifact not found: ${params.artifactId}`);
+      }
+
+      return agentManager.runTool({
+        name: targetToolName,
+        request: {
+          artifact,
+          text: params.text,
+          args: normalizeArgs(params.args)
+        },
+        chatId: scopedChatId
+      });
+    }
+
     if (method === "artifacts.createText") {
       const scopedChatId = requireChatId(chatId, method);
       return artifactStore.forChat(scopedChatId).createText({

package/src/runtime/bootstrap.js

@@ -24,17 +24,6 @@ async function exists(file) {
   }
 }
 
-function normalizeString(value) {
-  if (typeof value !== "string") return "";
-  return value.trim();
-}
-
-function parseMaxChatIds(value, fallback = 1) {
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
-  return parsed;
-}
-
 function buildConfig({ telegramApiKey, telegramMaxChatIds, provider, model, piApiKey }) {
   return {
     telegram: {
@@ -52,37 +41,6 @@ function buildConfig({ telegramApiKey, telegramMaxChatIds, provider, model, piAp
   };
 }
 
-function resolvePiDefaults(runtime, { provider: preferredProvider = "", model: preferredModel = "" } = {}) {
-  const providers = sortBootstrapProviders(listPiProviders(runtime));
-  if (!providers.length) {
-    throw new Error("No Pi providers are available for bootstrap.");
-  }
-
-  const preferredProviderValue = normalizeString(preferredProvider);
-  const providerExists = providers.some((item) => item.provider === preferredProviderValue);
-  if (preferredProviderValue && !providerExists) {
-    console.log(`Ignoring unknown Pi provider override: ${preferredProviderValue}`);
-  }
-
-  const selectedProvider = providerExists
-    ? preferredProviderValue
-    : providers[0].provider;
-
-  const models = sortBootstrapModels(selectedProvider, listProviderModels(selectedProvider, runtime));
-  if (!models.length) {
-    throw new Error(`No Pi models are available for provider ${selectedProvider}.`);
-  }
-
-  const preferredModelValue = normalizeString(preferredModel);
-  const modelExists = models.some((item) => item.id === preferredModelValue);
-  if (preferredModelValue && !modelExists) {
-    console.log(`Ignoring unknown Pi model override for ${selectedProvider}: ${preferredModelValue}`);
-  }
-
-  const selectedModel = modelExists ? preferredModelValue : models[0].id;
-  return { provider: selectedProvider, model: selectedModel };
-}
-
 function sortBootstrapProviders(providers) {
   const preferredOrder = ["openai-codex"];
   const positions = new Map(providers.map((provider, index) => [provider.provider, index]));
@@ -131,89 +89,13 @@ async function maybeOpenExternal(url) {
   });
 }
 
-function installAuthRelay(httpPort, setHttpRequestHandler) {
-  let authUrl = "";
-  let resolveRedirectUrl;
-  const redirectUrlPromise = new Promise((resolve) => {
-    resolveRedirectUrl = resolve;
-  });
-
-  const page = (body) => [
-    "<!DOCTYPE html><html><head><meta charset='utf-8'><meta name='viewport' content='width=device-width'>",
-    "<title>Arisa Auth</title>",
-    "<style>body{font-family:system-ui,sans-serif;max-width:600px;margin:40px auto;padding:0 20px;line-height:1.6}",
-    "input[type=text]{width:100%;padding:8px;box-sizing:border-box;margin:8px 0}",
-    "button{padding:8px 24px;cursor:pointer}code{background:#f0f0f0;padding:2px 6px;border-radius:3px}</style>",
-    "</head><body>",
-    body,
-    "</body></html>"
-  ].join("");
-
-  setHttpRequestHandler((req, res) => {
-    const parsed = new URL(req.url, `http://localhost:${httpPort}`);
-
-    if (req.method === "GET" && parsed.pathname === "/auth/callback" && parsed.searchParams.has("code")) {
-      const callbackUrl = `http://localhost:1455${parsed.pathname}${parsed.search}`;
-      resolveRedirectUrl(callbackUrl);
-      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-      res.end(page("<h2>Authentication received</h2><p>You can close this page. Arisa is starting&hellip;</p>"));
-      return;
-    }
-
-    if (req.method === "GET" && parsed.pathname === "/") {
-      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-      res.end(page([
-        "<h2>Arisa &mdash; Pi Authentication</h2>",
-        authUrl
-          ? `<p><strong>1.</strong> <a href="${authUrl}" target="_blank">Click here to log in with Pi</a></p>`
-          : "<p>Waiting for authentication URL&hellip;</p>",
-        "<p><strong>2.</strong> After login your browser will redirect to a <code>localhost</code> URL that won't load. That's expected.</p>",
-        "<p><strong>3.</strong> In your browser's address bar, replace <code>localhost:1455</code> with your server's domain and press Enter.</p>",
-        "<hr>",
-        "<p><em>Or paste the full redirect URL here:</em></p>",
-        '<form method="POST" action="/auth/relay">',
-        '<input type="text" name="url" placeholder="Paste the localhost redirect URL here&hellip;" required />',
-        "<button type='submit'>Submit</button>",
-        "</form>"
-      ].join("\n")));
-      return;
-    }
-
-    if (req.method === "POST" && parsed.pathname === "/auth/relay") {
-      let body = "";
-      req.on("data", (chunk) => { body += chunk; });
-      req.on("end", () => {
-        const url = (new URLSearchParams(body).get("url") || "").trim();
-        if (url) resolveRedirectUrl(url);
-        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(page("<h2>Authentication received</h2><p>You can close this page. Arisa is starting&hellip;</p>"));
-      });
-      return;
-    }
-
-    res.writeHead(200, { "Content-Type": "text/plain" });
-    res.end("ok");
-  });
-
-  return {
-    setAuthUrl(url) { authUrl = url; },
-    waitForRedirectUrl() { return redirectUrlPromise; },
-    uninstall() { setHttpRequestHandler(null); }
-  };
-}
-
-async function runInternalPiLogin(provider, { rl = null, authRelay = null } = {}) {
+async function runInternalPiLogin(provider, { rl = null } = {}) {
   const login = createPiOAuthLogin({
     provider,
     onAuth: async ({ url, instructions, controller }) => {
       console.log(`${instructions || "Open this URL to continue authentication:"}\n${url}\n`);
       await maybeOpenExternal(url);
-      if (authRelay) {
-        authRelay.setAuthUrl(url);
-        console.log("Waiting for authentication via the web relay...");
-        const redirectUrl = await authRelay.waitForRedirectUrl();
-        if (redirectUrl) controller.submitManualCode(redirectUrl);
-      } else if (controller.oauthProvider.usesCallbackServer && rl) {
+      if (controller.oauthProvider.usesCallbackServer && rl) {
         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) controller.submitManualCode(pasted);
       }
@@ -236,54 +118,10 @@ async function runInternalPiLogin(provider, { rl = null, authRelay = null } = {}
   await login.promise;
 }
 
-export async function bootstrapIfNeeded({ force = false, cliConfigOverrides = {}, httpPort = 0, setHttpRequestHandler } = {}) {
+export async function bootstrapIfNeeded({ force = false } = {}) {
   await ensureArisaHome();
   if (!force && await exists(configFile)) return;
 
-  const telegramApiKeyFromCli = normalizeString(cliConfigOverrides?.telegram?.token);
-  if (telegramApiKeyFromCli) {
-    const runtime = createPiRuntime();
-    const resolvedPi = resolvePiDefaults(runtime, cliConfigOverrides?.pi || {});
-    const telegramMaxChatIds = parseMaxChatIds(cliConfigOverrides?.telegram?.maxChatIds, 1);
-    const piApiKey = normalizeString(cliConfigOverrides?.pi?.apiKey);
-    if (!piApiKey && !hasProviderAuth(resolvedPi.provider, runtime)) {
-      if (!supportsProviderOAuth(resolvedPi.provider, runtime)) {
-        throw new Error(
-          `No auth found for ${resolvedPi.provider}. Provide --pi.apiKey for non-interactive bootstrap, or use a provider that supports OAuth.`
-        );
-      }
-      if (!httpPort || !setHttpRequestHandler) {
-        throw new Error(
-          `No auth found for ${resolvedPi.provider}. Arisa's HTTP server is unavailable; set ARISA_HTTP_PORT or free the configured port.`
-        );
-      }
-      const authRelay = installAuthRelay(httpPort, setHttpRequestHandler);
-      console.log(`No existing Pi auth found for ${resolvedPi.provider}. Auth relay active on port ${httpPort}.`);
-      console.log(`Open your server URL in a browser to complete Pi authentication.\n`);
-      try {
-        await runInternalPiLogin(resolvedPi.provider, { authRelay });
-      } finally {
-        authRelay.uninstall();
-      }
-      if (!hasProviderAuth(resolvedPi.provider, createPiRuntime())) {
-        throw new Error(
-          `Pi login did not complete for ${resolvedPi.provider}. Retry or provide --pi.apiKey.`
-        );
-      }
-      console.log(`Detected Pi auth for ${resolvedPi.provider}. Continuing bootstrap.`);
-    }
-    const config = buildConfig({
-      telegramApiKey: telegramApiKeyFromCli,
-      telegramMaxChatIds,
-      provider: resolvedPi.provider,
-      model: resolvedPi.model,
-      piApiKey
-    });
-    await writeFile(configFile, `${JSON.stringify(config, null, 2)}\n`, "utf8");
-    console.log(`\nConfig saved to ${configFile} (non-interactive bootstrap)\n`);
-    return;
-  }
-
   const rl = readline.createInterface({ input, output });
   const ask = async (label, fallback = "") => {
     const suffix = fallback ? ` (${fallback})` : "";

package/src/runtime/create-app.js

@@ -46,7 +46,7 @@ function applyRuntimeOverrides(config, runtimeOverrides) {
   };
 }
 
-export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpRequestHandler } = {}) {
+export async function createApp({ logger, runtimeOverrides } = {}) {
   logger?.log("app", "loading config");
   const persistedConfig = await loadConfig();
   const config = applyRuntimeOverrides(persistedConfig, runtimeOverrides);
@@ -62,9 +62,9 @@ export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpR
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);
 
   const agentManager = new AgentManager({ config, artifactStore, toolRegistry, taskStore, logger });
-  const arisaCapabilities = createArisaCapabilities({ artifactStore, taskStore });
+  const arisaCapabilities = createArisaCapabilities({ artifactStore, taskStore, agentManager });
   const ipcServer = createIpcServer({ capabilities: arisaCapabilities, logger });
-  const bot = await createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger, webhookUrl, setHttpRequestHandler });
+  const bot = await createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger });
 
   return {
     async start() {

package/src/runtime/service-manager.js

@@ -36,7 +36,7 @@ export async function getServiceStatus() {
   return { running: true, pid };
 }
 
-export async function startService({ verbose = false, cliArgs = [] } = {}) {
+export async function startService({ verbose = true, cliArgs = [] } = {}) {
   await ensureArisaHome();
   const status = await getServiceStatus();
   if (status.running) {
@@ -45,7 +45,7 @@ export async function startService({ verbose = false, cliArgs = [] } = {}) {
 
   const logHandle = await open(serviceLogFile, "a");
   const args = [entryFile, "--service-runner", ...cliArgs];
-  if (verbose) args.push("--verbose");
+  if (!verbose) args.push("--silent");
 
   const child = spawn(process.execPath, args, {
     detached: true,

package/src/transport/telegram/bot.js

@@ -1,4 +1,4 @@
-import { Bot, InputFile, webhookCallback } from "grammy";
+import { Bot, InputFile } from "grammy";
 import path from "node:path";
 import { authorizeChat } from "./auth.js";
 import { captureIncomingArtifact } from "./media.js";
@@ -251,7 +251,7 @@ async function withTyping(ctx, work) {
   }
 }
 
-export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger, webhookUrl, webRouter }) {
+export async function createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger }) {
   const bot = new Bot(config.telegram.token);
   const perChatState = new Map();
   const notifiedPromptErrors = new WeakSet();
@@ -736,25 +736,10 @@ export async function createTelegramBot({ config, artifactStore, toolRegistry, t
         }, 1000);
         taskTimer.unref();
       }
-      if (webhookUrl && webRouter) {
-        const webhookPath = `/telegram-${config.telegram.token.slice(-8)}`;
-        const handleUpdate = webhookCallback(bot, "http", {
-          timeoutMilliseconds: 60_000,
-          onTimeout: "return",
-        });
-        webRouter.registerCoreRoute({
-          method: "POST",
-          path: webhookPath,
-          handler: handleUpdate
-        });
-        await bot.api.setWebhook(`${webhookUrl}${webhookPath}`);
-        logger?.log("telegram", `webhook mode: ${webhookUrl}${webhookPath}`);
-        scheduleStartupMessages({ skipAgentStartupPrompts });
-      } else {
-        logger?.log("telegram", "bot polling started");
-        scheduleStartupMessages({ skipAgentStartupPrompts });
-        await bot.start({ drop_pending_updates: true });
-      }
+      await bot.api.deleteWebhook({ drop_pending_updates: true });
+      logger?.log("telegram", "bot polling started");
+      scheduleStartupMessages({ skipAgentStartupPrompts });
+      await bot.start();
     },
 
     async stop() {

package/test/ipc-server.test.js

@@ -59,13 +59,18 @@ function createFakeTaskStore() {
   };
 }
 
-function createCapabilities() {
+function createCapabilities(overrides = {}) {
   return createArisaCapabilities({
-    artifactStore: createFakeArtifactStore(),
-    taskStore: createFakeTaskStore()
+    artifactStore: overrides.artifactStore || createFakeArtifactStore(),
+    taskStore: overrides.taskStore || createFakeTaskStore(),
+    agentManager: overrides.agentManager
   });
 }
 
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 async function createTempSocketPath() {
   const root = await mkdtemp(path.join(os.tmpdir(), "arisa-ipc-"));
   return path.join(root, "arisa.sock");
@@ -141,6 +146,114 @@ test("requires chatId for chat-scoped capabilities", async () => {
   }
 });
 
+test("runs a registered tool over local IPC", async () => {
+  const socketPath = await createTempSocketPath();
+  const calls = [];
+  const agentManager = {
+    runTool: async (request) => {
+      calls.push(request);
+      return { ok: true, status: "ok", output: { text: "generated code" } };
+    }
+  };
+  const ipcServer = createIpcServer({ capabilities: createCapabilities({ agentManager }), socketPath });
+  await ipcServer.start();
+
+  try {
+    const client = createArisaClient({ toolName: "strudel-ui", chatId: "chat-1", socketPath });
+    const result = await client.tools.run({
+      name: "strudel-agent",
+      text: "make acid house",
+      args: {
+        bpm: 128,
+        tags: ["acid", "live"],
+        currentCode: "stack(s(\"bd\"))"
+      }
+    });
+
+    assert.deepEqual(result, { ok: true, status: "ok", output: { text: "generated code" } });
+    assert.equal(calls.length, 1);
+    assert.equal(calls[0].name, "strudel-agent");
+    assert.equal(calls[0].chatId, "chat-1");
+    assert.equal(calls[0].request.text, "make acid house");
+    assert.deepEqual(calls[0].request.args, {
+      bpm: 128,
+      tags: ["acid", "live"],
+      currentCode: "stack(s(\"bd\"))"
+    });
+    assert.equal(calls[0].request.artifact, null);
+  } finally {
+    await ipcServer.stop();
+  }
+});
+
+test("hydrates artifact input before running a tool over IPC", async () => {
+  const socketPath = await createTempSocketPath();
+  const calls = [];
+  const agentManager = {
+    runTool: async (request) => {
+      calls.push(request);
+      return { ok: true, status: "ok", output: { json: { received: true } } };
+    }
+  };
+  const ipcServer = createIpcServer({ capabilities: createCapabilities({ agentManager }), socketPath });
+  await ipcServer.start();
+
+  try {
+    const client = createArisaClient({ toolName: "strudel-ui", chatId: 123, socketPath });
+    const artifact = await client.artifacts.createText({ text: "current pattern" });
+    await client.tools.run({ name: "strudel-agent", artifactId: artifact.id });
+
+    assert.equal(calls.length, 1);
+    assert.deepEqual(calls[0].request.artifact, artifact);
+  } finally {
+    await ipcServer.stop();
+  }
+});
+
+test("requires chatId when running a tool over IPC", async () => {
+  const socketPath = await createTempSocketPath();
+  const agentManager = {
+    runTool: async () => ({ ok: true, status: "ok" })
+  };
+  const ipcServer = createIpcServer({ capabilities: createCapabilities({ agentManager }), socketPath });
+  await ipcServer.start();
+
+  try {
+    const client = createArisaClient({ toolName: "strudel-ui", socketPath });
+    await assert.rejects(
+      () => client.tools.run({ name: "strudel-agent" }),
+      /tools\.run requires chatId/
+    );
+  } finally {
+    await ipcServer.stop();
+  }
+});
+
+test("supports per-call IPC timeout overrides", async () => {
+  const socketPath = await createTempSocketPath();
+  const agentManager = {
+    runTool: async () => {
+      await wait(25);
+      return { ok: true, status: "ok" };
+    }
+  };
+  const ipcServer = createIpcServer({ capabilities: createCapabilities({ agentManager }), socketPath });
+  await ipcServer.start();
+
+  try {
+    const client = createArisaClient({ toolName: "strudel-ui", chatId: 123, socketPath });
+    const result = await client.tools.run({ name: "strudel-agent" }, { timeoutMs: 250 });
+    assert.deepEqual(result, { ok: true, status: "ok" });
+
+    await assert.rejects(
+      () => client.tools.run({ name: "strudel-agent" }, { timeoutMs: 1 }),
+      /Arisa IPC request timed out/
+    );
+  } finally {
+    await ipcServer.stop();
+  }
+});
+
 test("listens on a local socket, not a TCP port", async () => {
   const socketPath = await createTempSocketPath();
   const ipcServer = createIpcServer({ capabilities: createCapabilities(), socketPath });

package/src/runtime/process-ids.js

@@ -1,9 +0,0 @@
-export function parseProcessIds(commandOutput) {
-  if (!commandOutput) return [];
-
-  return commandOutput
-    .split(/\s+/)
-    .filter((token) => /^\d+$/.test(token))
-    .map(Number)
-    .filter((pid) => Number.isInteger(pid) && pid > 0);
-}

package/test/process-ids.test.js

@@ -1,14 +0,0 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { parseProcessIds } from "../src/runtime/process-ids.js";
-
-test("ignores empty PID command output", () => {
-  assert.deepEqual(parseProcessIds(""), []);
-  assert.deepEqual(parseProcessIds("   \n\t"), []);
-});
-
-test("parses only positive integer PID tokens", () => {
-  assert.deepEqual(parseProcessIds("123\n456"), [123, 456]);
-  assert.deepEqual(parseProcessIds("11970/tcp: 1234"), [1234]);
-  assert.deepEqual(parseProcessIds("0 nope -12 42"), [42]);
-});