argsbarg 4.0.3 → 4.1.0

package/src/docs/mcp-resources.ts

@@ -0,0 +1,68 @@
+/*
+Auto MCP resources for user docs.topics when docs and MCP are both enabled.
+*/
+
+import type { CliProgram } from "../types.ts";
+import {
+  docsEnabled,
+  docsTopicContent,
+  docsTopicDescription,
+  docsUserTopicKeys,
+} from "./resolve.ts";
+
+/** Default URI pattern for a docs topic MCP resource (`<mcpId>://docs/<topicKey>`). */
+export function defaultDocsTopicResourceUri(mcpId: string, topicKey: string): string {
+  return `${mcpId}://docs/${topicKey}`;
+}
+
+/** Sanitized MCP server id from program key (matches mcpServerId in mcp/tools.ts). */
+function mcpIdFromProgram(program: CliProgram): string {
+  return program.key.replace(/[^a-zA-Z0-9]/g, "_");
+}
+
+/** Resolved URI for one user docs topic resource. */
+export function resolveDocsTopicResourceUri(program: CliProgram, topicKey: string): string {
+  return defaultDocsTopicResourceUri(mcpIdFromProgram(program), topicKey);
+}
+
+/** All auto-generated docs topic resources (empty when docs or MCP disabled). */
+export function docsMcpResources(program: CliProgram): {
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType: string;
+  load: () => string;
+}[] {
+  if (!docsEnabled(program) || program.mcpServer?.enabled !== true) {
+    return [];
+  }
+  const docs = program.docs;
+  if (!docs) {
+    return [];
+  }
+  return docsUserTopicKeys(docs).map((key) => {
+    const topic = docs.topics[key];
+    if (!topic) {
+      throw new Error(`docs topic missing: ${key}`);
+    }
+    return {
+      uri: resolveDocsTopicResourceUri(program, key),
+      name: key,
+      description: docsTopicDescription(key, topic.description),
+      mimeType: "text/markdown",
+      load: () => docsTopicContent(program, key),
+    };
+  });
+}
+
+/** Reserved MCP resource URIs from auto docs topics (for validation). */
+export function reservedDocsTopicResourceUris(program: CliProgram): string[] {
+  if (!docsEnabled(program) || program.mcpServer?.enabled !== true) {
+    return [];
+  }
+  const docs = program.docs;
+  if (!docs) {
+    return [];
+  }
+  return docsUserTopicKeys(docs).map((key) => resolveDocsTopicResourceUri(program, key));
+}

package/src/hidden-mcpb.test.ts

@@ -19,7 +19,7 @@ const hiddenFixture: CliProgram = {
   key: "myapp",
   version: "1.0.0",
   description: "Hidden demo.",
-  mcpServer: { enabled: true },
+  mcpServer: { enabled: true, mcpd: true, claudePlugin: true },
   commands: [
     {
       key: "public",
@@ -187,4 +187,44 @@ describe("mcp bundle", () => {
       rmSync(work, { recursive: true, force: true });
     }
   });
+
+  test("runMcpBundle with claudePlugin only prints plugin path", () => {
+    const work = mkdtempSync(join(tmpdir(), "mcpb-run-"));
+    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, claudePlugin: 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("claude-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/);
+  });
 });

package/src/index.ts

@@ -43,6 +43,7 @@ export type {
   CliDocsTopic,
   CliHandler,
   CliInstallConfig,
+  CliInstallTargets,
   CliInvocation,
   CliMcpBundleConfig,
   CliMcpResource,
@@ -53,6 +54,9 @@ export type {
   CliProgram,
   CliUpdateArtifact,
   CliUpdateGetLatest,
+  InstallAgentIntegration,
+  InstallTargetSpec,
+  ResolvedInstallTarget,
 } from "./types.ts";
 export {
   CliFallbackMode,

package/src/install/{binary.ts → app.ts}

@@ -17,32 +17,32 @@ import {
   removeRcBlock,
 } from "./shell.ts";
 
-export interface BinaryInstallResult {
+export interface AppInstallResult {
   changedFiles: string[];
   patchedBashRc: boolean;
   patchedZshRc: boolean;
 }
 
-/** Copies a binary to the install path and patches rc files when shells are detected. */
-export function installBinary(
+/** Copies the app executable to the install path and patches rc files when shells are detected. */
+export function installApp(
   root: CliProgram,
   paths: InstallPaths,
   dry: boolean,
   sourcePath: string = process.execPath,
-): BinaryInstallResult {
+): AppInstallResult {
   const changed: string[] = [];
   const shells = detectShells();
   let patchedBashRc = false;
   let patchedZshRc = false;
 
   if (!dry) {
-    mkdirSync(paths.bindir, { recursive: true });
-    copyFileSync(sourcePath, paths.binaryPath);
+    mkdirSync(paths.appDir, { recursive: true });
+    copyFileSync(sourcePath, paths.appPath);
   }
-  changed.push(paths.binaryPath);
+  changed.push(paths.appPath);
 
   if (shells.bash && existsSync(dirname(paths.bashRc))) {
-    const block = buildPathRcBlock(root.key, paths.bindir);
+    const block = buildPathRcBlock(root.key, paths.appDir);
     let content = existsSync(paths.bashRc) ? readFileSync(paths.bashRc, "utf8") : "";
     if (!hasRcBlock(content, root.key, "path")) {
       if (!content.endsWith("\n") && content.length > 0) content += "\n";
@@ -69,12 +69,12 @@ export function installBinary(
   return { changedFiles: changed, patchedBashRc, patchedZshRc };
 }
 
-/** Removes binary and rc marker blocks. */
-export function uninstallBinary(root: CliProgram, paths: InstallPaths, dry: boolean): string[] {
+/** Removes the installed app and rc marker blocks. */
+export function uninstallApp(root: CliProgram, paths: InstallPaths, dry: boolean): string[] {
   const changed: string[] = [];
-  if (existsSync(paths.binaryPath)) {
-    if (!dry) unlinkSync(paths.binaryPath);
-    changed.push(paths.binaryPath);
+  if (existsSync(paths.appPath)) {
+    if (!dry) unlinkSync(paths.appPath);
+    changed.push(paths.appPath);
   }
 
   for (const [rcPath, tag] of [

package/src/install/bootstrap.ts

@@ -0,0 +1,22 @@
+import { existsSync } from "node:fs";
+import type { CliProgram } from "../types.ts";
+import { resolveAppDir } from "./paths.ts";
+
+/** Rewrites empty argv to `install` when the app is not yet installed (TTY only). */
+export function maybeBootstrapInstallArgv(argv: string[], program: CliProgram): string[] {
+  if (argv.length !== 0) {
+    return argv;
+  }
+  if (program.install?.enabled === false) {
+    return argv;
+  }
+  if (!process.stdin.isTTY) {
+    return argv;
+  }
+  const appDir = resolveAppDir();
+  const appPath = `${appDir}/${program.key}`;
+  if (existsSync(appPath)) {
+    return argv;
+  }
+  return ["install"];
+}

package/src/install/detect-installed.ts

@@ -1,97 +1,2 @@
-import { existsSync, readFileSync } from "node:fs";
-import { codexMcpHasServer } from "./mcp-codex.ts";
-import { detectOpenCodeMcpConfigPath } from "./mcp-opencode.ts";
-import { type InstallPaths, userHome } from "./paths.ts";
-
-export interface InstalledArtifacts {
-  binary: boolean;
-  bashCompletion: boolean;
-  zshCompletion: boolean;
-  fishCompletion: boolean;
-  cursorSkill: boolean;
-  claudeSkill: boolean;
-  cursorMcp: boolean;
-  claudeMcp: boolean;
-  claudeDesktopMcp: boolean;
-  opencodeMcp: boolean;
-  codexMcp: boolean;
-  chatGptMcp: boolean;
-  bashRcPath: boolean;
-  zshRcFpath: boolean;
-}
-
-function mcpConfigHasServer(path: string, name: string): boolean {
-  if (!existsSync(path)) return false;
-  try {
-    const data = JSON.parse(readFileSync(path, "utf8")) as { mcpServers?: Record<string, unknown> };
-    return data.mcpServers?.[name] !== undefined;
-  } catch {
-    return false;
-  }
-}
-
-/** Detects which install artifacts are currently present. */
-export function detectInstalledArtifacts(paths: InstallPaths): InstalledArtifacts {
-  return {
-    binary: existsSync(paths.binaryPath),
-    bashCompletion: existsSync(paths.bashCompletion),
-    zshCompletion: existsSync(paths.zshCompletion),
-    fishCompletion: existsSync(paths.fishCompletion),
-    cursorSkill: existsSync(paths.cursorSkillDir),
-    claudeSkill: existsSync(paths.claudeSkillDir),
-    cursorMcp: mcpConfigHasServer(paths.cursorMcpPath, paths.mcpName),
-    claudeMcp: mcpConfigHasServer(paths.claudeMcpPath, paths.mcpName),
-    claudeDesktopMcp: mcpConfigHasServer(paths.claudeDesktopMcpPath, paths.mcpName),
-    opencodeMcp: detectOpenCodeMcpConfigPath(userHome(), paths.mcpName) !== undefined,
-    codexMcp: codexMcpHasServer(userHome(), paths.mcpName),
-    chatGptMcp: mcpConfigHasServer(paths.chatGptMcpPath, paths.mcpName),
-    bashRcPath: false,
-    zshRcFpath: false,
-  };
-}
-
-export interface InstallStatus {
-  binary?: string;
-  bashCompletion?: string;
-  zshCompletion?: string;
-  fishCompletion?: string;
-  cursorSkill?: string;
-  claudeSkill?: string;
-  cursorMcp?: string;
-  claudeMcp?: string;
-  claudeDesktopMcp?: string;
-  opencodeMcp?: string;
-  codexMcp?: string;
-  chatGptMcp?: string;
-}
-
-/** Builds a status inventory from detected artifacts. */
-export function buildInstallStatus(
-  paths: InstallPaths,
-  detected: InstalledArtifacts,
-): InstallStatus {
-  const status: InstallStatus = {};
-  if (detected.binary) status.binary = paths.binaryPath;
-  if (detected.bashCompletion) status.bashCompletion = paths.bashCompletion;
-  if (detected.zshCompletion) status.zshCompletion = paths.zshCompletion;
-  if (detected.fishCompletion) status.fishCompletion = paths.fishCompletion;
-  if (detected.cursorSkill) status.cursorSkill = `${paths.cursorSkillDir}/`;
-  if (detected.claudeSkill) status.claudeSkill = `${paths.claudeSkillDir}/`;
-  if (detected.cursorMcp) status.cursorMcp = `${paths.cursorMcpPath} (server "${paths.mcpName}")`;
-  if (detected.claudeMcp) status.claudeMcp = `${paths.claudeMcpPath} (server "${paths.mcpName}")`;
-  if (detected.claudeDesktopMcp) {
-    status.claudeDesktopMcp = `${paths.claudeDesktopMcpPath} (server "${paths.mcpName}")`;
-  }
-  if (detected.opencodeMcp) {
-    const openCodePath =
-      detectOpenCodeMcpConfigPath(userHome(), paths.mcpName) ?? paths.opencodeMcpPath;
-    status.opencodeMcp = `${openCodePath} (server "${paths.mcpName}")`;
-  }
-  if (detected.codexMcp) {
-    status.codexMcp = `${paths.codexConfigPath} (server "${paths.mcpName}")`;
-  }
-  if (detected.chatGptMcp) {
-    status.chatGptMcp = `${paths.chatGptMcpPath} (server "${paths.mcpName}")`;
-  }
-  return status;
-}
+export { buildInstallStatus, detectInstalledArtifacts } from "./target-detect.ts";
+export type { InstalledArtifacts, InstallStatus } from "./target-types.ts";