argsbarg 3.4.2 → 3.6.0

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 {
@@ -111,6 +113,38 @@ export function buildUninstallPlan(
         },
       });
     }
+    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;
@@ -120,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

@@ -3,11 +3,19 @@ Packs a CLI program into an MCP Bundle (`.mcpb`) for Claude Desktop.
 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);
     }
@@ -208,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-"));
@@ -218,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,22 @@ 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,
+  CliValueFormat,
+  isCliLeaf,
+  leafOutputSchema,
+} from "../types.ts";
+
+const DURATION_PATTERN = "^\\d+[hdms]?$";
 
 /** Default URI pattern for the CLI schema MCP resource (`<mcpId>://schema`). */
 export function defaultMcpSchemaUri(mcpId: string): string {
@@ -56,12 +68,37 @@ export function mcpToolName(root: CliProgram, path: string[]): string {
 
 /** JSON Schema property for one option. */
 function optionProperty(opt: CliOption): Record<string, unknown> {
-  const base = { description: opt.description };
+  const base: Record<string, unknown> = { description: opt.description };
+  if (opt.default !== undefined) {
+    base.default = opt.default;
+  }
   switch (opt.kind) {
     case CliOptionKind.Presence:
       return { type: "boolean", ...base };
-    case CliOptionKind.String:
-      return { type: "string", ...base };
+    case CliOptionKind.String: {
+      if (opt.format === CliValueFormat.CommaList) {
+        return {
+          oneOf: [
+            { type: "string", ...base },
+            { type: "array", items: { type: "string" }, ...base },
+          ],
+        };
+      }
+      const stringBase = { type: "string", ...base };
+      if (opt.format === CliValueFormat.Duration) {
+        return { ...stringBase, pattern: DURATION_PATTERN };
+      }
+      if (opt.format === CliValueFormat.Date) {
+        return { ...stringBase, format: "date" };
+      }
+      if (opt.format === CliValueFormat.DateTime) {
+        return { ...stringBase, format: "date-time" };
+      }
+      if (opt.pattern !== undefined) {
+        return { ...stringBase, pattern: opt.pattern };
+      }
+      return stringBase;
+    }
     case CliOptionKind.Number:
       return { type: "number", ...base };
     case CliOptionKind.Enum:
@@ -69,6 +106,23 @@ function optionProperty(opt: CliOption): Record<string, unknown> {
   }
 }
 
+function formatMcpOptionValue(opt: CliOption, val: unknown): string | { error: string } {
+  if (opt.format === CliValueFormat.CommaList) {
+    if (Array.isArray(val)) {
+      const items = val.map(String).filter(Boolean);
+      if (items.length === 0) {
+        return { error: `Option --${opt.name} requires at least one value` };
+      }
+      return items.join(",");
+    }
+    if (typeof val === "string") {
+      return val;
+    }
+    return { error: `Option --${opt.name} must be a string or array of strings` };
+  }
+  return String(val);
+}
+
 /** JSON Schema property for one positional slot. */
 function positionalProperty(p: CliPositional): Record<string, unknown> {
   const base = { description: p.description };
@@ -80,7 +134,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[] = [];
 
@@ -238,7 +296,11 @@ export function mcpToolCallToArgv(
       }
       continue;
     }
-    argv.push(`--${opt.name}`, String(val));
+    const formatted = formatMcpOptionValue(opt, val);
+    if (typeof formatted !== "string") {
+      return formatted;
+    }
+    argv.push(`--${opt.name}`, formatted);
   }
 
   for (const p of tool.leaf.positionals ?? []) {
@@ -247,17 +309,20 @@ export function mcpToolCallToArgv(
 
     if (argMax === 0) {
       const raw = args[p.name];
-      let items: string[];
-      if (Array.isArray(raw)) {
-        items = raw.map(String);
-      } else if (typeof raw === "string") {
-        items = raw.includes(",")
-          ? raw.split(",").map((s) => s.trim()).filter(Boolean)
-          : raw.trim()
-            ? [raw.trim()]
-            : [];
-      } else {
-        items = [];
+      if (raw === undefined) {
+        if (argMin >= 1) {
+          return { error: `Missing argument: ${p.name} (use a JSON array)` };
+        }
+        continue;
+      }
+      if (!Array.isArray(raw)) {
+        return {
+          error: `Argument ${p.name} must be a JSON array of strings (not a comma-separated string)`,
+        };
+      }
+      const items = raw.map(String).filter(Boolean);
+      if (items.length === 0 && argMin >= 1) {
+        return { error: `Missing argument: ${p.name}` };
       }
       argv.push(...items);
       continue;

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");
     }