arisa 3.0.12 → 3.1.2

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

@@ -0,0 +1,90 @@
+function mimeMatches(pattern, mimeType = "") {
+  if (!pattern || !mimeType) return false;
+  if (pattern === mimeType) return true;
+  if (pattern.endsWith("/*")) return mimeType.startsWith(`${pattern.slice(0, -2)}/`);
+  return false;
+}
+
+function toolSupportsArtifact(tool, artifact) {
+  const inputs = Array.isArray(tool.input) ? tool.input : [];
+  return inputs.some((input) => mimeMatches(input, artifact.mimeType));
+}
+
+function toolProduces(tool, mimeType) {
+  const outputs = Array.isArray(tool.output) ? tool.output : [];
+  return outputs.some((output) => mimeMatches(output, mimeType));
+}
+
+function looksLikeAudioTranscriptionTool(tool) {
+  return /transcri|whisper|speech.?to.?text|audio.?to.?text/i.test(`${tool.name} ${tool.description || ""}`);
+}
+
+function shouldNormalizeAudioToText(artifact, desiredMimeType) {
+  return artifact?.mimeType?.startsWith("audio/") && desiredMimeType === "text/plain";
+}
+
+export function selectPipeTool({ toolRegistry, artifact, desiredMimeType }) {
+  const tools = toolRegistry.list()
+    .filter((tool) => toolSupportsArtifact(tool, artifact))
+    .filter((tool) => toolProduces(tool, desiredMimeType));
+
+  if (shouldNormalizeAudioToText(artifact, desiredMimeType)) {
+    return tools.find(looksLikeAudioTranscriptionTool) || null;
+  }
+
+  return null;
+}
+
+export async function normalizeArtifactForReasoning({
+  artifact,
+  desiredMimeType = "text/plain",
+  toolRegistry,
+  chatArtifactStore,
+  chatId
+}) {
+  if (!artifact) return { normalizedArtifact: null, toolResult: null, toolName: "" };
+
+  if (!shouldNormalizeAudioToText(artifact, desiredMimeType)) {
+    return { normalizedArtifact: null, toolResult: null, toolName: "" };
+  }
+
+  const tool = selectPipeTool({ toolRegistry, artifact, desiredMimeType });
+  if (!tool) {
+    return {
+      normalizedArtifact: null,
+      toolResult: {
+        ok: false,
+        status: "failed",
+        error: `No registered tool can normalize ${artifact.mimeType} to ${desiredMimeType}.`
+      },
+      toolName: ""
+    };
+  }
+
+  const result = await toolRegistry.run({
+    name: tool.name,
+    request: { artifact, args: {} },
+    chatId
+  });
+
+  if (!result.ok) {
+    return { normalizedArtifact: null, toolResult: result, toolName: tool.name };
+  }
+
+  if (!result.output?.text) {
+    return {
+      normalizedArtifact: null,
+      toolResult: { ok: false, status: "failed", error: "Normalization returned no text." },
+      toolName: tool.name
+    };
+  }
+
+  const normalizedArtifact = await chatArtifactStore.createText({
+    text: result.output.text,
+    mimeType: desiredMimeType,
+    source: { type: "tool", toolName: tool.name },
+    metadata: { fromArtifactId: artifact.id, tool: tool.name, normalization: true }
+  });
+
+  return { normalizedArtifact, toolResult: result, toolName: tool.name };
+}

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

@@ -0,0 +1,169 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+import { tasksFile } from "../../runtime/paths.js";
+
+async function loadTasksFile() {
+  try {
+    return JSON.parse(await readFile(tasksFile, "utf8"));
+  } catch {
+    return [];
+  }
+}
+
+async function saveTasksFile(tasks) {
+  await mkdir(path.dirname(tasksFile), { recursive: true });
+  await writeFile(tasksFile, `${JSON.stringify(tasks, null, 2)}\n`, "utf8");
+}
+
+function taskId() {
+  return crypto.randomUUID();
+}
+
+function normalizeTask(task, defaults = {}) {
+  return {
+    id: task.id || taskId(),
+    status: task.status || "pending",
+    createdAt: task.createdAt || new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    kind: task.kind,
+    runAt: task.runAt,
+    payload: {
+      ...(defaults.payload || {}),
+      ...(task.payload || {})
+    },
+    recurrence: task.recurrence || defaults.recurrence || null,
+    source: {
+      ...(defaults.source || {}),
+      ...(task.source || {})
+    }
+  };
+}
+
+function computeNextRunAt(task) {
+  if (task.recurrence?.type === "interval" && Number(task.recurrence.everySeconds) > 0) {
+    return new Date(Date.now() + (Number(task.recurrence.everySeconds) * 1000)).toISOString();
+  }
+  return "";
+}
+
+export class TaskStore {
+  constructor() {
+    this.tasks = null;
+  }
+
+  async init() {
+    if (!this.tasks) this.tasks = await loadTasksFile();
+  }
+
+  async reload() {
+    this.tasks = await loadTasksFile();
+  }
+
+  async save() {
+    await saveTasksFile(this.tasks || []);
+  }
+
+  async add(task, defaults = {}) {
+    await this.init();
+    const normalized = normalizeTask(task, defaults);
+    this.tasks.push(normalized);
+    await this.save();
+    return normalized;
+  }
+
+  async addMany(tasks = [], defaults = {}) {
+    const created = [];
+    for (const task of tasks) {
+      created.push(await this.add(task, defaults));
+    }
+    return created;
+  }
+
+  async claimDue(limit = 10) {
+    await this.reload();
+    const now = Date.now();
+    const due = [];
+
+    for (const task of this.tasks) {
+      if (due.length >= limit) break;
+      if (task.status !== "pending") continue;
+      if (!task.runAt || Number.isNaN(Date.parse(task.runAt))) continue;
+      if (Date.parse(task.runAt) > now) continue;
+      task.status = "running";
+      task.updatedAt = new Date().toISOString();
+      due.push({ ...task });
+    }
+
+    if (due.length) await this.save();
+    return due;
+  }
+
+  async complete(taskId) {
+    await this.init();
+    const task = this.tasks.find((item) => item.id === taskId);
+    if (!task) return null;
+
+    const nextRunAt = computeNextRunAt(task);
+    if (nextRunAt) {
+      task.status = "pending";
+      task.runAt = nextRunAt;
+      task.lastRunAt = new Date().toISOString();
+    } else {
+      task.status = "done";
+      task.completedAt = new Date().toISOString();
+    }
+    task.updatedAt = new Date().toISOString();
+    await this.save();
+    return task;
+  }
+
+  async fail(taskId, error) {
+    await this.init();
+    const task = this.tasks.find((item) => item.id === taskId);
+    if (!task) return null;
+    task.status = "failed";
+    task.error = error;
+    task.updatedAt = new Date().toISOString();
+    await this.save();
+    return task;
+  }
+
+  async list(filter = {}) {
+    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;
+      if (filter.kind && task.kind !== filter.kind) return false;
+      return true;
+    });
+  }
+
+  async get(taskId) {
+    await this.reload();
+    return this.tasks.find((item) => item.id === taskId) || null;
+  }
+
+  async cancel(taskId) {
+    await this.reload();
+    const index = this.tasks.findIndex((item) => item.id === taskId);
+    if (index === -1) return null;
+    const [task] = this.tasks.splice(index, 1);
+    await this.save();
+    return task;
+  }
+
+  async cancelAll(filter = {}) {
+    await this.reload();
+    const removed = [];
+    this.tasks = this.tasks.filter((task) => {
+      if (filter.chatId && task.payload?.chatId !== filter.chatId) return true;
+      if (filter.status && task.status !== filter.status) return true;
+      if (task.status === "done" || task.status === "failed") return true;
+      removed.push({ ...task });
+      return false;
+    });
+    if (removed.length) await this.save();
+    return removed;
+  }
+}

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");
@@ -119,7 +130,11 @@ export class ToolRegistry {
     try {
       const parsed = JSON.parse(result.stdout || result.stderr);
       const normalized = normalizeToolResult(name, parsed);
-      this.logger?.log("tools", `${name} -> ${normalized.ok === false ? normalized.status || "error" : "ok"}`);
+      if (normalized.ok === false) {
+        this.logger?.log("tools", `${name} -> ${normalized.status || "error"}: ${normalized.error || "unknown error"}`);
+      } else {
+        this.logger?.log("tools", `${name} -> ok`);
+      }
       return normalized;
     } catch {
       return normalizeToolResult(name, {

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;