arisa 4.0.18 → 4.0.20

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.20",
   "description": "Telegram + Pi Agent modular assistant",
   "type": "module",
   "main": "src/index.js",

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/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);
@@ -64,7 +64,7 @@ export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpR
   const agentManager = new AgentManager({ config, artifactStore, toolRegistry, taskStore, logger });
   const arisaCapabilities = createArisaCapabilities({ artifactStore, taskStore });
   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/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]);
-});