argsbarg 7.0.11 → 7.1.1

package/src/mcp/hidden-mcpb.test.ts

@@ -222,11 +222,44 @@ describe("mcp bundle", () => {
     }
   });
 
+  /** RunMcpBundle with cursorPlugin only prints plugin path. */
+  test("runMcpBundle with cursorPlugin only prints plugin path", () => {
+    const work = mkdtempSync(join(tmpdir(), "mcpb-run-cursor-"));
+    const stdout: string[] = [];
+    const orig = process.stdout.write.bind(process.stdout);
+    process.stdout.write = ((chunk: string | Uint8Array) => {
+      stdout.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8"));
+      return true;
+    }) as typeof process.stdout.write;
+    const fixture: CliProgram = {
+      ...hiddenFixture,
+      mcpServer: { enabled: true, cursorPlugin: true },
+    };
+    try {
+      const dist = join(work, "dist");
+      mkdirSync(dist, { recursive: true });
+      writeFileSync(join(dist, "myapp"), "#!/bin/sh\n", { mode: 0o755 });
+      const prevCwd = process.cwd();
+      process.chdir(work);
+      try {
+        runMcpBundle(fixture);
+      } finally {
+        process.chdir(prevCwd);
+      }
+      const lines = stdout.join("").trim().split("\n");
+      expect(lines).toHaveLength(1);
+      expect(lines[0]).toContain("cursor-plugin");
+    } finally {
+      process.stdout.write = orig;
+      rmSync(work, { recursive: true, force: true });
+    }
+  });
+
   test("runMcpBundle errors when no bundle flags enabled", () => {
     const fixture: CliProgram = {
       ...hiddenFixture,
       mcpServer: { enabled: true },
     };
-    expect(() => runMcpBundle(fixture)).toThrow(/mcpd/);
+    expect(() => runMcpBundle(fixture)).toThrow(/cursorPlugin/);
   });
 });

package/src/mcp/plugin-shared.ts

@@ -0,0 +1,107 @@
+/*
+Shared utilities and staging helpers for Claude Code and Cursor plugin packages.
+Internal module — not exported from index.ts.
+*/
+
+import {
+  cpSync,
+  type Dirent,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { join, relative, resolve } from "node:path";
+import type { CliMcpBundleConfig, CliProgram } from "../core/types.ts";
+import { generatePluginSkillBundle } from "../skill/generate.ts";
+import { applyPluginSkillHint } from "../skill/hint.ts";
+import { sanitizeToolSegment } from "./tools.ts";
+import type { ZipFileEntry } from "./zip.ts";
+
+/**
+ * Traverses a staging directory recursively and gathers ZIP entries preserving executable permissions.
+ */
+export function collectZipEntries(
+  /** Directory containing the staged files. */
+  rootDir: string,
+  /** Subdirectory currently being traversed (defaults to rootDir). */
+  dir = rootDir,
+): ZipFileEntry[] {
+  const entries: ZipFileEntry[] = [];
+  for (const ent of readdirSync(dir, { withFileTypes: true }) as Dirent[]) {
+    const full = join(dir, ent.name);
+    if (ent.isDirectory()) {
+      entries.push(...collectZipEntries(rootDir, full));
+      continue;
+    }
+    if (!ent.isFile()) {
+      continue;
+    }
+    const rel = relative(rootDir, full).split("\\").join("/");
+    const stMode = statSync(full).mode;
+    const entry: ZipFileEntry = { name: rel, data: readFileSync(full) };
+    if (stMode & 0o111) {
+      entry.unixMode = stMode;
+    }
+    entries.push(entry);
+  }
+  return entries;
+}
+
+/**
+ * Returns author metadata from bundle config or fallback defaults.
+ */
+export function defaultAuthor(
+  /** Optional bundle configuration. */
+  bundle?: CliMcpBundleConfig,
+): {
+  name: string;
+  email?: string;
+  url?: string;
+} {
+  return bundle?.author ?? { name: "Unknown" };
+}
+
+/**
+ * Generates kebab-case plugin name for plugin manifests.
+ */
+export function pluginName(
+  /** CLI program schema. */
+  program: CliProgram,
+): string {
+  return program.key
+    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replace(/[^a-zA-Z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase();
+}
+
+/**
+ * Stages repository skill directory if present, or writes a generated MCP routing skill.
+ */
+export function stagePluginSkills(
+  /** Plugin staging root directory. */
+  pluginRoot: string,
+  /** CLI program schema. */
+  program: CliProgram,
+  /** Working directory containing repository sources. */
+  cwd: string,
+): void {
+  const dirName = sanitizeToolSegment(program.key);
+  const repoSkillDir = program.mcpServer?.bundle?.skillsDir
+    ? resolve(cwd, program.mcpServer.bundle.skillsDir)
+    : join(cwd, "skills", dirName);
+
+  if (existsSync(repoSkillDir) && statSync(repoSkillDir).isDirectory()) {
+    const targetDir = join(pluginRoot, "skills", dirName);
+    mkdirSync(join(targetDir, ".."), { recursive: true });
+    cpSync(repoSkillDir, targetDir, { recursive: true });
+  } else {
+    const bundle = generatePluginSkillBundle(program);
+    const skillMd = applyPluginSkillHint(program, bundle.skillMd);
+    mkdirSync(join(pluginRoot, "skills", bundle.dirName), { recursive: true });
+    writeFileSync(join(pluginRoot, "skills", bundle.dirName, "SKILL.md"), skillMd);
+  }
+}

package/src/mcp/result.ts

@@ -38,6 +38,7 @@ export interface McpBinaryRespondContent {
 export function buildToolCallSuccessFromResponse(response: CliRespondOptions): McpToolCallSuccess {
   const { body, contentType = "application/json; charset=utf-8" } = response;
   let structuredContent: unknown;
+  let text = "";
 
   if (body instanceof Uint8Array) {
     structuredContent = {
@@ -45,17 +46,20 @@ export function buildToolCallSuccessFromResponse(response: CliRespondOptions): M
       contentType,
       encoding: "base64",
     } satisfies McpBinaryRespondContent;
+    text = `[Binary data: ${contentType}, ${body.length} bytes]`;
   } else if (typeof body === "string") {
     structuredContent = {
       content: body,
       contentType,
     } satisfies McpStringRespondContent;
+    text = body;
   } else {
     structuredContent = body;
+    text = typeof body === "object" && body !== null ? JSON.stringify(body, null, 2) : String(body ?? "");
   }
 
   return {
-    content: [{ type: "text", text: "" }],
+    content: [{ type: "text", text }],
     structuredContent,
     isError: false,
   };

package/src/mcp/server.ts

@@ -253,8 +253,9 @@ async function handleRequestLine(cli: Cli, line: string): Promise<void> {
 /** Runs the MCP NDJSON read loop on stdin until EOF. */
 export async function mcpServeStdioLoop(cli: Cli): Promise<void> {
   let buffer = "";
-  for await (const chunk of Bun.stdin.stream()) {
-    buffer += new TextDecoder().decode(chunk);
+  const decoder = new TextDecoder();
+  for await (const chunk of process.stdin) {
+    buffer += typeof chunk === "string" ? chunk : decoder.decode(chunk);
     let nl = buffer.indexOf("\n");
     while (nl !== -1) {
       const line = buffer.slice(0, nl).trim();

package/src/test/fixtures.ts

@@ -1,10 +1,23 @@
 import type { CliProgram } from "../core/types.ts";
 import { CliFallbackMode, CliOptionKind } from "../core/types.ts";
+import type { McpToolDef } from "../mcp/tools.ts";
 
 export function testProgram(prog: Record<string, unknown> & { key: string; description: string }): CliProgram {
   return { version: "0.0.0", ...prog } as CliProgram;
 }
 
+/** MCP tool with `name` from `collectMcpTools`, or throw. */
+export function requireMcpTool(
+  /** Tools from `collectMcpTools`. */
+  tools: McpToolDef[],
+  /** MCP tool name to find. */
+  name: string,
+): McpToolDef {
+  const tool = tools.find((t) => t.name === name);
+  if (!tool) throw new Error(`expected MCP tool ${name}`);
+  return tool;
+}
+
 export const nestedMcpFixture = testProgram({
   key: "nested.ts",
   description: "Nested groups demo.",

package/src/test/integration/mcp.test.ts

@@ -16,7 +16,7 @@ import {
   mcpToolName,
   sanitizeToolSegment,
 } from "../../mcp/tools.ts";
-import { mcpRequest, nestedMcpFixture, testProgram } from "../fixtures.ts";
+import { mcpRequest, nestedMcpFixture, requireMcpTool, testProgram } from "../fixtures.ts";
 
 test("sanitizeToolSegment normalizes dotted app keys", () => {
   expect(sanitizeToolSegment("minimal.ts")).toBe("minimal_ts");
@@ -39,7 +39,7 @@ test("collectMcpTools lists user leaf commands only", () => {
   const tools = collectMcpTools(nestedMcpFixture);
   const names = tools.map((t) => t.name);
   expect(names).toContain("stat_owner_lookup");
-  const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
+  const lookup = requireMcpTool(tools, "stat_owner_lookup");
   expect(lookup.description).toBe("stat owner lookup — Resolve owner info.");
   expect(names).toContain("read");
   expect(names).not.toContain("hidden");
@@ -155,7 +155,7 @@ test("outputSchema must be a JSON Schema object", () => {
 
 test("collectMcpTools uses leaf-local options in inputSchema", () => {
   const tools = collectMcpTools(nestedMcpFixture);
-  const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
+  const lookup = requireMcpTool(tools, "stat_owner_lookup");
   const schema = lookup.inputSchema as { properties: Record<string, unknown>; required?: string[] };
   expect(schema.properties.json).toBeUndefined();
   expect(schema.properties["user-name"]).toBeDefined();
@@ -193,13 +193,13 @@ test("collectMcpTools includes outputSchema when set on leaf", () => {
 
 test("collectMcpTools omits outputSchema when leaf has none", () => {
   const tools = collectMcpTools(nestedMcpFixture);
-  const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
+  const lookup = requireMcpTool(tools, "stat_owner_lookup");
   expect(lookup.outputSchema).toBeUndefined();
 });
 
 test("mcpToolCallToArgv builds nested lookup argv", () => {
   const tools = collectMcpTools(nestedMcpFixture);
-  const lookup = tools.find((t) => t.name === "stat_owner_lookup")!;
+  const lookup = requireMcpTool(tools, "stat_owner_lookup");
   const argv = mcpToolCallToArgv(nestedMcpFixture, lookup, {
     "user-name": "alice",
     path: "./x",
@@ -209,7 +209,7 @@ test("mcpToolCallToArgv builds nested lookup argv", () => {
 
 test("mcpToolCallToArgv expands varargs positionals", () => {
   const tools = collectMcpTools(nestedMcpFixture);
-  const read = tools.find((t) => t.name === "read")!;
+  const read = requireMcpTool(tools, "read");
   const argv = mcpToolCallToArgv(nestedMcpFixture, read, { files: ["a", "b"] });
   expect(argv).toEqual(["read", "a", "b"]);
 });
@@ -318,7 +318,7 @@ test("buildToolCallSuccessFromResponse maps JSON object", () => {
   const result = buildToolCallSuccessFromResponse({ body: { a: 1 } });
   expect(result.isError).toBe(false);
   expect(result.structuredContent).toEqual({ a: 1 });
-  expect(result.content[0]?.text).toBe("");
+  expect(result.content[0]?.text).toBe(JSON.stringify({ a: 1 }, null, 2));
 });
 
 test("buildToolCallSuccessFromResponse maps string body", () => {
@@ -330,6 +330,7 @@ test("buildToolCallSuccessFromResponse maps string body", () => {
     content: "lookup user=x",
     contentType: "text/plain; charset=utf-8",
   });
+  expect(result.content[0]?.text).toBe("lookup user=x");
 });
 
 test("buildToolCallSuccessFromResponse maps binary body as base64", () => {

package/examples/full-example/scripts/print-identity.ts

@@ -1,28 +0,0 @@
-#!/usr/bin/env bun
-/** Print a field from scripts/create-identity.ts for justfile backticks. */
-
-import { createIdentity } from "./create-identity.ts";
-
-const field = process.argv[2];
-if (!field) {
-  console.error("Usage: bun scripts/print-identity.ts <key|className|tap|tapOrg|tapRepo|releaseRepo|envPrefix>");
-  process.exit(1);
-}
-
-const [tapOrg, tapRepo] = createIdentity.tap.split("/");
-const values: Record<string, string> = {
-  key: createIdentity.key,
-  className: createIdentity.className,
-  tap: createIdentity.tap,
-  tapOrg: tapOrg ?? "",
-  tapRepo: tapRepo ?? "",
-  envPrefix: createIdentity.envPrefix,
-  releaseRepo: createIdentity.releaseRepo,
-};
-
-const value = values[field];
-if (value === undefined) {
-  console.error(`Unknown field: ${field}`);
-  process.exit(1);
-}
-process.stdout.write(value);

package/examples/full-example-json/scripts/print-identity.ts

@@ -1,28 +0,0 @@
-#!/usr/bin/env bun
-/** Print a field from scripts/create-identity.ts for justfile backticks. */
-
-import { createIdentity } from "./create-identity.ts";
-
-const field = process.argv[2];
-if (!field) {
-  console.error("Usage: bun scripts/print-identity.ts <key|className|tap|tapOrg|tapRepo|releaseRepo|envPrefix>");
-  process.exit(1);
-}
-
-const [tapOrg, tapRepo] = createIdentity.tap.split("/");
-const values: Record<string, string> = {
-  key: createIdentity.key,
-  className: createIdentity.className,
-  tap: createIdentity.tap,
-  tapOrg: tapOrg ?? "",
-  tapRepo: tapRepo ?? "",
-  envPrefix: createIdentity.envPrefix,
-  releaseRepo: createIdentity.releaseRepo,
-};
-
-const value = values[field];
-if (value === undefined) {
-  console.error(`Unknown field: ${field}`);
-  process.exit(1);
-}
-process.stdout.write(value);