argsbarg 3.4.1 → 3.5.0

package/src/install/status.ts

@@ -1,22 +1,22 @@
-import { CliProgram } from "../types.ts";
+import type { CliProgram } from "../types.ts";
 import { buildInstallStatus, detectInstalledArtifacts } from "./detect-installed.ts";
-import type { InstallOpts } from "./plan.ts";
 import { resolveInstallPaths } from "./paths.ts";
+import type { InstallOpts } from "./plan.ts";
 
 export function installOut(msg: string, opts: InstallOpts): void {
   if (opts.quiet || opts.json) return;
-  process.stdout.write(msg + "\n");
+  process.stdout.write(`${msg}\n`);
 }
 
 export function installInfo(msg: string, opts: InstallOpts): void {
   if (opts.quiet) return;
   if (opts.json && !opts.dry) return;
   const prefix = opts.dry ? "[dry run] " : "";
-  process.stderr.write(prefix + msg + "\n");
+  process.stderr.write(`${prefix + msg}\n`);
 }
 
 export function installErr(msg: string): void {
-  process.stderr.write(msg + "\n");
+  process.stderr.write(`${msg}\n`);
 }
 
 /** Prints install status to stdout (human or JSON). */
@@ -35,7 +35,11 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
     if (status.claudeSkill) json.claudeSkill = status.claudeSkill;
     if (status.cursorMcp) json.cursorMcp = status.cursorMcp;
     if (status.claudeMcp) json.claudeMcp = status.claudeMcp;
-    process.stdout.write(JSON.stringify(json, null, 2) + "\n");
+    if (status.claudeDesktopMcp) json.claudeDesktopMcp = status.claudeDesktopMcp;
+    if (status.opencodeMcp) json.opencodeMcp = status.opencodeMcp;
+    if (status.codexMcp) json.codexMcp = status.codexMcp;
+    if (status.chatGptMcp) json.chatGptMcp = status.chatGptMcp;
+    process.stdout.write(`${JSON.stringify(json, null, 2)}\n`);
     return;
   }
 
@@ -48,7 +52,11 @@ export function printInstallStatus(root: CliProgram, opts: InstallOpts): void {
     ["cursor skill", status.cursorSkill],
     ["claude skill", status.claudeSkill],
     ["cursor mcp", status.cursorMcp],
-    ["claude mcp", status.claudeMcp],
+    ["claude code mcp", status.claudeMcp],
+    ["claude desktop mcp", status.claudeDesktopMcp],
+    ["opencode mcp", status.opencodeMcp],
+    ["codex mcp", status.codexMcp],
+    ["chatgpt desktop mcp", status.chatGptMcp],
   ];
   let any = false;
   for (const [label, value] of lines) {

package/src/install/uninstall.ts

@@ -1,16 +1,18 @@
 import { existsSync, rmSync } from "node:fs";
-import { CliProgram } from "../types.ts";
+import type { CliProgram } from "../types.ts";
 import { uninstallBinary } from "./binary.ts";
 import { uninstallCompletions } from "./completions.ts";
 import { detectInstalledArtifacts } from "./detect-installed.ts";
+import { removeCodexMcpConfig } from "./mcp-codex.ts";
 import { removeMcpConfig } from "./mcp-config.ts";
-import { InstallPaths } from "./paths.ts";
+import { detectOpenCodeMcpConfigPath, removeOpenCodeMcpConfig } from "./mcp-opencode.ts";
+import { type InstallPaths, userHome } from "./paths.ts";
 import {
+  type InstallOpts,
   wantsInstallBin,
   wantsInstallCompletions,
   wantsInstallMcp,
   wantsInstallSkill,
-  type InstallOpts,
 } from "./plan.ts";
 
 export interface UninstallAction {
@@ -93,7 +95,7 @@ export function buildUninstallPlan(
     }
     if (detected.claudeMcp) {
       actions.push({
-        summary: `claude mcp: ${paths.claudeMcpPath}`,
+        summary: `claude code mcp: ${paths.claudeMcpPath}`,
         message: `Removing MCP server "${paths.mcpName}" from ${paths.claudeMcpPath}`,
         run: () => {
           removeMcpConfig(paths.claudeMcpPath, paths.mcpName, dry);
@@ -101,6 +103,48 @@ export function buildUninstallPlan(
         },
       });
     }
+    if (detected.claudeDesktopMcp) {
+      actions.push({
+        summary: `claude desktop mcp: ${paths.claudeDesktopMcpPath}`,
+        message: `Removing MCP server "${paths.mcpName}" from ${paths.claudeDesktopMcpPath}`,
+        run: () => {
+          removeMcpConfig(paths.claudeDesktopMcpPath, paths.mcpName, dry);
+          return [paths.claudeDesktopMcpPath];
+        },
+      });
+    }
+    if (detected.opencodeMcp) {
+      const openCodePath =
+        detectOpenCodeMcpConfigPath(userHome(), paths.mcpName) ?? paths.opencodeMcpPath;
+      actions.push({
+        summary: `opencode mcp: ${openCodePath}`,
+        message: `Removing MCP server "${paths.mcpName}" from ${openCodePath}`,
+        run: () => {
+          removeOpenCodeMcpConfig(openCodePath, paths.mcpName, dry);
+          return [openCodePath];
+        },
+      });
+    }
+    if (detected.codexMcp) {
+      actions.push({
+        summary: `codex mcp: ${paths.codexConfigPath}`,
+        message: `Removing MCP server "${paths.mcpName}" from Codex via codex mcp remove`,
+        run: () => {
+          removeCodexMcpConfig(userHome(), paths.mcpName, dry);
+          return [paths.codexConfigPath];
+        },
+      });
+    }
+    if (detected.chatGptMcp) {
+      actions.push({
+        summary: `chatgpt desktop mcp: ${paths.chatGptMcpPath}`,
+        message: `Removing MCP server "${paths.mcpName}" from ${paths.chatGptMcpPath}`,
+        run: () => {
+          removeMcpConfig(paths.chatGptMcpPath, paths.mcpName, dry);
+          return [paths.chatGptMcpPath];
+        },
+      });
+    }
   }
 
   return actions;
@@ -110,5 +154,5 @@ export function buildUninstallPlan(
 export function uninstallSkillDir(dir: string, dry: boolean): string[] {
   if (!existsSync(dir)) return [];
   if (!dry) rmSync(dir, { recursive: true, force: true });
-  return [dir + "/"];
+  return [`${dir}/`];
 }

package/src/install/update.test.ts

@@ -1,7 +1,7 @@
-import { expect, test, beforeEach, afterEach } from "bun:test";
+import { afterEach, beforeEach, expect, test } from "bun:test";
 import { chmodSync, existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { join } from "node:path";
 import { cliPresentationRoot } from "../builtins/presentation.ts";
 import { cliInvoke } from "../index.ts";
 import type { CliProgram, CliUpdateArtifact } from "../types.ts";

package/src/install/update.ts

@@ -7,7 +7,9 @@ import { installErr } from "./status.ts";
 export async function cliUpdate(root: CliProgram): Promise<never> {
   const hook = root.install?.updateGetLatest;
   if (!hook) {
-    installErr("install --update is not configured. Set install.updateGetLatest on the program root.");
+    installErr(
+      "install --update is not configured. Set install.updateGetLatest on the program root.",
+    );
     process.exit(1);
   }
 

package/src/invoke.ts

@@ -4,12 +4,12 @@ It parses argv against the user schema, captures stdout/stderr, and patches
 process.exit so MCP tool calls can run handlers repeatedly.
 */
 
-import { CliContext } from "./context.ts";
+import { format } from "node:util";
 import { builtinInterceptRoot, dispatchBuiltin } from "./builtins/dispatch.ts";
 import { cliParseRoot, cliPresentationRoot } from "./builtins/presentation.ts";
-import { parse, postParseValidate, ParseKind } from "./parse.ts";
+import { CliContext } from "./context.ts";
+import { ParseKind, parse, postParseValidate } from "./parse.ts";
 import { type CliNode, type CliProgram, type CliRouter, isCliLeaf, isCliRouter } from "./types.ts";
-import { format } from "node:util";
 
 /** Outcome of a non-exiting CLI invocation. */
 export type CliInvokeKind = "ok" | "help" | "error";
@@ -159,21 +159,24 @@ export async function cliInvoke(root: CliProgram, argv: string[]): Promise<CliIn
   }) as typeof process.stderr.write;
 
   console.log = (...args: unknown[]) => {
-    stdout += format(...args) + "\n";
+    stdout += `${format(...args)}\n`;
   };
   console.info = (...args: unknown[]) => {
-    stdout += format(...args) + "\n";
+    stdout += `${format(...args)}\n`;
   };
   console.warn = (...args: unknown[]) => {
-    stderr += format(...args) + "\n";
+    stderr += `${format(...args)}\n`;
   };
   console.error = (...args: unknown[]) => {
-    stderr += format(...args) + "\n";
+    stderr += `${format(...args)}\n`;
   };
 
   try {
     if (pr.kind === ParseKind.Ok) {
-      await dispatchBuiltin(root, pr, { isLeafCompletionIntercept, parseRoot: completionParseRoot });
+      await dispatchBuiltin(root, pr, {
+        isLeafCompletionIntercept,
+        parseRoot: completionParseRoot,
+      });
     }
 
     await Promise.resolve(handler(ctx));
@@ -191,7 +194,7 @@ export async function cliInvoke(root: CliProgram, argv: string[]): Promise<CliIn
         kind: "error",
         exitCode: 1,
         stdout,
-        stderr: err.message + "\n",
+        stderr: `${err.message}\n`,
         errorMsg: err.message,
       };
     }

package/src/mcp/bundle.ts

@@ -1,13 +1,21 @@
 /*
 Packs a CLI program into an MCP Bundle (`.mcpb`) for Claude Desktop.
-macOS-only v1: expects `dist/<program.key>` as the compiled binary input.
+Expects `dist/<program.key>` as the compiled binary input.
 */
 
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join, resolve } from "node:path";
-import { collectMcpTools, mcpServerId } from "./tools.ts";
 import type { CliMcpBundleConfig, CliProgram } from "../types.ts";
+import { collectMcpTools, mcpServerId } from "./tools.ts";
 
 const MANIFEST_VERSION = "0.3";
 const DIST_DIR = "dist";
@@ -51,7 +59,11 @@ function buildUserConfig(program: CliProgram): Record<string, unknown> | undefin
   }
   const out: Record<string, unknown> = {};
   for (const name of envVars) {
-    const key = name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "") || "env_var";
+    const key =
+      name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_|_$/g, "") || "env_var";
     out[key] = {
       type: "string",
       title: name,
@@ -64,12 +76,19 @@ function buildUserConfig(program: CliProgram): Record<string, unknown> | undefin
 }
 
 /** Default author when `mcpServer.bundle.author` is unset. */
-function defaultAuthor(bundle?: CliMcpBundleConfig): { name: string; email?: string; url?: string } {
+function defaultAuthor(bundle?: CliMcpBundleConfig): {
+  name: string;
+  email?: string;
+  url?: string;
+} {
   return bundle?.author ?? { name: "Unknown" };
 }
 
 /** Generates MCPB `manifest.json` object from program schema and MCP tools. */
-export function generateMcpManifest(program: CliProgram, binaryName: string): Record<string, unknown> {
+export function generateMcpManifest(
+  program: CliProgram,
+  binaryName: string,
+): Record<string, unknown> {
   const bundle = program.mcpServer?.bundle;
   const tools = collectMcpTools(program).map((t) => ({
     name: t.name,
@@ -119,7 +138,11 @@ export function generateMcpManifest(program: CliProgram, binaryName: string): Re
 function crc32(data: Buffer): number {
   let crc = 0xffffffff;
   for (let i = 0; i < data.length; i++) {
-    crc ^= data[i]!;
+    const byte = data[i];
+    if (byte === undefined) {
+      continue;
+    }
+    crc ^= byte;
     for (let j = 0; j < 8; j++) {
       crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
     }
@@ -198,13 +221,9 @@ export interface PackMcpBundleOpts {
 
 /**
  * Stages manifest + binary (+ optional icon) and writes a `.mcpb` ZIP.
- * macOS-only v1; requires the compiled binary to exist.
+ * Requires the compiled binary to exist.
  */
 export function packMcpBundle(program: CliProgram, opts: PackMcpBundleOpts = {}): string {
-  if (process.platform !== "darwin") {
-    throw new Error("mcp bundle is macOS-only in this release. Build the bundle on darwin.");
-  }
-
   const cwd = opts.cwd ?? process.cwd();
   const defaults = defaultMcpBundlePaths(program, cwd);
   const binaryPath = resolve(cwd, opts.binaryPath ?? defaults.binaryPath);
@@ -212,7 +231,9 @@ export function packMcpBundle(program: CliProgram, opts: PackMcpBundleOpts = {})
   const binaryName = basename(binaryPath);
 
   if (!existsSync(binaryPath)) {
-    throw new Error(`Binary not found: ${binaryPath}. Build with compile first (expected dist/${program.key}).`);
+    throw new Error(
+      `Binary not found: ${binaryPath}. Build with compile first (expected dist/${program.key}).`,
+    );
   }
 
   const staging = mkdtempSync(join(tmpdir(), "mcpb-"));
@@ -222,7 +243,10 @@ export function packMcpBundle(program: CliProgram, opts: PackMcpBundleOpts = {})
 
     const manifest = generateMcpManifest(program, binaryName);
     const files: { name: string; data: Buffer }[] = [
-      { name: "manifest.json", data: Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8") },
+      {
+        name: "manifest.json",
+        data: Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`, "utf8"),
+      },
       { name: binaryName, data: readFileSync(stagedBinary) },
     ];
 

package/src/mcp/env.ts

@@ -2,8 +2,8 @@
 This module bootstraps process.env for MCP servers from login shell and .env files.
 */
 
-import { readFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 
 /** Parses `env` stdout from a login shell into a key/value map. */
 export function captureShellEnv(shell: string): Record<string, string> {
@@ -42,9 +42,7 @@ export function applyShellEnv(env: Record<string, string>): void {
 
 /** Loads a .env file into process.env (always overwrites). Warns on stderr if missing. */
 export function loadEnvFile(envFile: string): void {
-  const resolved = envFile.startsWith("~")
-    ? envFile.replace("~", process.env.HOME ?? "")
-    : envFile;
+  const resolved = envFile.startsWith("~") ? envFile.replace("~", process.env.HOME ?? "") : envFile;
   let text: string;
   try {
     text = readFileSync(resolved, "utf8");
@@ -63,10 +61,7 @@ export function loadEnvFile(envFile: string): void {
     }
     const key = trimmed.slice(0, eq).trim();
     let val = trimmed.slice(eq + 1).trim();
-    if (
-      (val.startsWith('"') && val.endsWith('"')) ||
-      (val.startsWith("'") && val.endsWith("'"))
-    ) {
+    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
       val = val.slice(1, -1);
     }
     if (key) {
@@ -76,10 +71,7 @@ export function loadEnvFile(envFile: string): void {
 }
 
 /** Applies mcpServer shellEnv and envFile bootstrap in order. */
-export function bootstrapMcpEnv(config: {
-  shellEnv?: boolean | string;
-  envFile?: string;
-}): void {
+export function bootstrapMcpEnv(config: { shellEnv?: boolean | string; envFile?: string }): void {
   const shellEnvCfg = config.shellEnv;
   if (shellEnvCfg) {
     const shell =
@@ -88,7 +80,9 @@ export function bootstrapMcpEnv(config: {
         : (process.env.SHELL ?? (process.platform === "darwin" ? "/bin/zsh" : "/bin/bash"));
     const captured = captureShellEnv(shell);
     if (Object.keys(captured).length === 0) {
-      process.stderr.write(`[argsbarg] shellEnv: failed to capture shell environment from ${shell}\n`);
+      process.stderr.write(
+        `[argsbarg] shellEnv: failed to capture shell environment from ${shell}\n`,
+      );
     } else {
       applyShellEnv(captured);
     }

package/src/mcp/server.ts

@@ -4,7 +4,7 @@ resources, and ping. Responses are newline-delimited JSON on stdout only.
 */
 
 import { cliInvoke } from "../invoke.ts";
-import { CliProgram } from "../types.ts";
+import type { CliProgram } from "../types.ts";
 import { buildToolCallSuccess } from "./result.ts";
 import {
   allMcpResources,
@@ -25,7 +25,7 @@ interface JsonRpcRequest {
 
 /** Writes a JSON-RPC response line to stdout. */
 function writeResponse(msg: Record<string, unknown>): void {
-  process.stdout.write(JSON.stringify(msg) + "\n");
+  process.stdout.write(`${JSON.stringify(msg)}\n`);
 }
 
 /** Writes a JSON-RPC error response. */
@@ -108,7 +108,10 @@ async function handleRequestLine(root: CliProgram, line: string): Promise<void>
         return;
       }
       const rawArgs = params.arguments;
-      if (rawArgs !== undefined && (typeof rawArgs !== "object" || rawArgs === null || Array.isArray(rawArgs))) {
+      if (
+        rawArgs !== undefined &&
+        (typeof rawArgs !== "object" || rawArgs === null || Array.isArray(rawArgs))
+      ) {
         writeError(id, -32602, "Invalid params: arguments must be an object");
         return;
       }
@@ -151,7 +154,8 @@ async function handleRequestLine(root: CliProgram, line: string): Promise<void>
         });
         return;
       }
-      const errText = invokeResult.stderr.trim() || invokeResult.errorMsg || `Exit code ${invokeResult.exitCode}`;
+      const errText =
+        invokeResult.stderr.trim() || invokeResult.errorMsg || `Exit code ${invokeResult.exitCode}`;
       writeResponse({
         jsonrpc: "2.0",
         id,
@@ -222,14 +226,16 @@ export async function mcpServeStdioLoop(root: CliProgram): Promise<void> {
   let buffer = "";
   for await (const chunk of Bun.stdin.stream()) {
     buffer += new TextDecoder().decode(chunk);
-    let nl: number;
-    while ((nl = buffer.indexOf("\n")) !== -1) {
+    let nl = buffer.indexOf("\n");
+    while (nl !== -1) {
       const line = buffer.slice(0, nl).trim();
       buffer = buffer.slice(nl + 1);
       if (line.length === 0) {
+        nl = buffer.indexOf("\n");
         continue;
       }
       await handleRequestLine(root, line);
+      nl = buffer.indexOf("\n");
     }
   }
   const trailing = buffer.trim();

package/src/mcp/tools.ts

@@ -4,10 +4,19 @@ flat JSON tool arguments into argv for cliInvoke.
 */
 
 import { cliResolveNotes } from "../help.ts";
-import { collectOptionDefs } from "../parse.ts";
 import { visibleOptions } from "../hidden.ts";
+import { collectOptionDefs } from "../parse.ts";
 import { cliSchemaJson } from "../schema.ts";
-import { CliProgram, CliLeaf, CliNode, CliOption, CliOptionKind, CliPositional, isCliLeaf, isCliRouter, leafOutputSchema } from "../types.ts";
+import {
+  type CliLeaf,
+  type CliNode,
+  type CliOption,
+  CliOptionKind,
+  type CliPositional,
+  type CliProgram,
+  isCliLeaf,
+  leafOutputSchema,
+} from "../types.ts";
 
 /** Default URI pattern for the CLI schema MCP resource (`<mcpId>://schema`). */
 export function defaultMcpSchemaUri(mcpId: string): string {
@@ -80,7 +89,11 @@ function positionalProperty(p: CliPositional): Record<string, unknown> {
 }
 
 /** Builds inputSchema for a leaf command. */
-function buildInputSchema(root: CliProgram, path: string[], leaf: CliLeaf): Record<string, unknown> {
+function buildInputSchema(
+  root: CliProgram,
+  path: string[],
+  leaf: CliLeaf,
+): Record<string, unknown> {
   const properties: Record<string, unknown> = {};
   const required: string[] = [];
 
@@ -252,7 +265,10 @@ export function mcpToolCallToArgv(
         items = raw.map(String);
       } else if (typeof raw === "string") {
         items = raw.includes(",")
-          ? raw.split(",").map((s) => s.trim()).filter(Boolean)
+          ? raw
+              .split(",")
+              .map((s) => s.trim())
+              .filter(Boolean)
           : raw.trim()
             ? [raw.trim()]
             : [];

package/src/mcp.ts

@@ -2,9 +2,9 @@
 This module starts the ArgsBarg MCP stdio server for opt-in program roots.
 */
 
-import { mcpServeStdioLoop } from "./mcp/server.ts";
 import { bootstrapMcpEnv } from "./mcp/env.ts";
-import { CliProgram } from "./types.ts";
+import { mcpServeStdioLoop } from "./mcp/server.ts";
+import type { CliProgram } from "./types.ts";
 
 /**
  * Runs the MCP JSON-RPC server on stdin/stdout until stdin closes, then exits.
@@ -19,7 +19,7 @@ export async function cliMcpServeStdio(root: CliProgram): Promise<never> {
     process.exit(0);
   } catch (err) {
     if (err instanceof Error) {
-      process.stderr.write(err.message + "\n");
+      process.stderr.write(`${err.message}\n`);
     } else {
       process.stderr.write("MCP server error.\n");
     }