@cmdforge/gen-apic-mp 0.0.1 → 0.0.2

package/src/server/marketplace.ts

@@ -0,0 +1,486 @@
+import { access, cp, mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+import { types } from "../shared/index.js";
+
+const execFileAsync = promisify(execFile);
+
+export class ApiCenterClient {
+  get serviceName() { return this.info.serviceName; }
+  get region() { return this.info.region; }
+  get workspaceName() { return this.info.workspaceName; }
+
+  constructor(public readonly info: types.WorkspaceInfo) { }
+
+  plane(plane: types.PlaneType) {
+    return `https://${this.serviceName}.${plane}.${this.region}.azure-apicenter.ms`;
+  }
+
+  path(plane: types.PlaneType, path: string) {
+    return `${this.plane(plane)}/${path}`;
+  }
+
+  url(plane: types.PlaneType, path: string, params: Record<string, unknown> = {}) {
+    const url = new URL(this.path(plane, path));
+    for (const [key, value] of Object.entries(params))
+      url.searchParams.set(key, `${value}`);
+    return url.toString();
+  }
+
+  workspace(path: string, params: Record<string, unknown> = {}) {
+    return this.url("data", `workspaces/${this.workspaceName}/${path}`, params);
+  }
+
+  async get<T>(url: string) {
+    const response = await fetch(url);
+    const body = await response.text();
+    try {
+      if (!response.ok) throw Error(`Could not read config from ${url}`);
+      return JSON.parse(body) as T;
+    } catch (e) {
+      throw Error(`url: ${url}, e: ${e}, body: ${body}`);
+    }
+  }
+
+  async *paged<T>(url: string) {
+    let nextLink = url;
+    do {
+      const result = await this.get<types.PagedResponse<T>>(nextLink);
+      if (result.value?.length > 0)
+        yield result.value;
+      nextLink = result.nextLink ?? "";
+    } while (nextLink);
+  }
+
+  async config() {
+    return this.get<types.PortalConfig>(this.url("portal", "config.json"));
+  }
+
+  apis($top = 50, $skip?: number) {
+    return this.paged<types.ApiAssetItem>(this.workspace("apis", { $top, $skip }));
+  }
+
+  async plugin(name: string) {
+    return this.get<types.PluginAsset>(this.workspace(`plugins/${name}`));
+  }
+
+  async mcp(resourceId: string) {
+    return this.get<types.McpAsset>(this.url("data", resourceId));
+  }
+
+  async v0Server(name: string) {
+    return this.get<types.V0ServerEntryResponse>(this.workspace(`v0/servers/${name}`));
+  }
+}
+
+function sanitizeName(value: string) {
+  return value
+    .trim()
+    .replace(/[^a-zA-Z0-9._-]+/g, "-")
+    .replace(/^-+|-+$/g, "") || "unnamed";
+}
+
+function asStringRecord(value: unknown) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return undefined;
+
+  const result: Record<string, string> = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item === undefined || item === null) continue;
+    result[key] = `${item}`;
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+function asStringArray(value: unknown) {
+  if (!Array.isArray(value)) return undefined;
+  const result = value.map(item => `${item}`);
+  return result.length > 0 ? result : undefined;
+}
+
+function asObjectArray(value: unknown) {
+  if (!Array.isArray(value)) return [];
+  return value.map(asObject).filter((item): item is Record<string, unknown> => !!item);
+}
+
+function pickObject(value: unknown, keys: string[]) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  for (const key of keys) {
+    if (key in value) {
+      const candidate = (value as Record<string, unknown>)[key];
+      if (candidate && typeof candidate === "object" && !Array.isArray(candidate))
+        return candidate as Record<string, unknown>;
+    }
+  }
+  return undefined;
+}
+
+function pickString(value: unknown, keys: string[]) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  for (const key of keys) {
+    const candidate = (value as Record<string, unknown>)[key];
+    if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  }
+  return undefined;
+}
+
+function asObject(value: unknown) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  return value as Record<string, unknown>;
+}
+
+function pickTransport(entry: Record<string, unknown>) {
+  const transport = pickString(entry, ["transport", "type", "protocol"]);
+  if (!transport) return undefined;
+  if (transport === "stdio") return "stdio";
+  if (transport === "sse") return "sse";
+  if (transport === "streamable-http" || transport === "http" || transport === "https")
+    return "http";
+  return undefined;
+}
+
+function compactObject<T extends Record<string, unknown>>(value: T): T {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== undefined),
+  ) as T;
+}
+
+function argumentValue(argument: Record<string, unknown>) {
+  const value = argument.value;
+  if (value === undefined || value === null) return undefined;
+  return `${value}`;
+}
+
+function packageEnv(packageEntry: Record<string, unknown>) {
+  const environmentVariables = asObjectArray(packageEntry.environmentVariables);
+  if (environmentVariables.length === 0) return undefined;
+
+  const result: Record<string, string> = {};
+  for (const variable of environmentVariables) {
+    const name = pickString(variable, ["name"]);
+    const value = argumentValue(variable);
+    if (!name || value === undefined) continue;
+    result[name] = value;
+  }
+
+  return Object.keys(result).length > 0 ? result : undefined;
+}
+
+function packageArgs(packageEntry: Record<string, unknown>) {
+  const runtimeArguments = asObjectArray(packageEntry.runtimeArguments);
+  const packageArguments = asObjectArray(packageEntry.packageArguments);
+  const identifier = pickString(packageEntry, ["identifier"]);
+  const version = pickString(packageEntry, ["version"]);
+  const registryType = pickString(packageEntry, ["registryType"]);
+  const command = pickString(packageEntry, ["runtimeHint"])
+    ?? (registryType === "npm" ? "npx"
+      : registryType === "pypi" ? "uvx"
+        : registryType === "oci" ? "docker"
+          : registryType === "nuget" ? "dnx"
+            : undefined);
+
+  const args: string[] = [];
+
+  for (const argument of runtimeArguments) {
+    const type = pickString(argument, ["type"]);
+    const name = pickString(argument, ["name"]);
+    const value = argumentValue(argument);
+
+    if (type === "named" && name) {
+      if (value === undefined || value === "true") {
+        args.push(name);
+      } else if (value !== "false") {
+        args.push(name, value);
+      }
+      continue;
+    }
+
+    if (value !== undefined)
+      args.push(value);
+  }
+
+  if (identifier) {
+    if (command === "npx") {
+      args.push("-y", version ? `${identifier}@${version}` : identifier);
+    } else if (command === "uvx" || command === "dnx") {
+      args.push(version ? `${identifier}@${version}` : identifier);
+    } else if (command === "docker") {
+      args.push("run", "--rm", version ? `${identifier}:${version}` : identifier);
+    } else {
+      args.push(version ? `${identifier}@${version}` : identifier);
+    }
+  }
+
+  for (const argument of packageArguments) {
+    const type = pickString(argument, ["type"]);
+    const name = pickString(argument, ["name"]);
+    const value = argumentValue(argument);
+
+    if (type === "named" && name) {
+      if (value === undefined || value === "true") {
+        args.push(name);
+      } else if (value !== "false") {
+        args.push(name, value);
+      }
+      continue;
+    }
+
+    if (value !== undefined)
+      args.push(value);
+  }
+
+  return {
+    command,
+    args: args.length > 0 ? args : undefined,
+    env: packageEnv(packageEntry),
+  };
+}
+
+function normalizeServerEntry(entry: types.V0ServerJsonEntry): Record<string, unknown> | undefined {
+  const record = asObject(entry);
+  if (!record) return undefined;
+
+  const nestedServer = asObject(record.server);
+  if (!nestedServer) return record;
+
+  const remotes = asObjectArray(nestedServer.remotes);
+  const primaryRemote = remotes.length > 0 ? remotes[0] : undefined;
+  const packages = asObjectArray(nestedServer.packages);
+  const primaryPackage = packages.length > 0 ? packages[0] : undefined;
+  const packageTransport = asObject(primaryPackage?.transport);
+  const packageLaunch = primaryPackage ? packageArgs(primaryPackage) : undefined;
+
+  return compactObject({
+    ...record,
+    ...nestedServer,
+    transport: pickString(primaryRemote, ["type"])
+      ?? pickString(packageTransport, ["type", "transport"])
+      ?? pickString(nestedServer, ["transport", "type"]),
+    url: pickString(primaryRemote, ["url"])
+      ?? pickString(packageTransport, ["url"])
+      ?? pickString(nestedServer, ["url"]),
+    headers: primaryRemote?.headers ?? packageTransport?.headers ?? nestedServer.headers,
+    command: packageLaunch?.command ?? pickString(nestedServer, ["command", "cmd"]),
+    args: packageLaunch?.args ?? nestedServer.args,
+    env: packageLaunch?.env ?? nestedServer.env,
+  });
+}
+
+export function mcpServerNameFromV0Entry(entry: types.V0ServerJsonEntry) {
+  const record = normalizeServerEntry(entry);
+  const name = pickString(record, ["name"]);
+  if (!name) {
+    throw new Error(
+      `Could not determine MCP server name from v0 server.json entry:\n${JSON.stringify(entry, null, 2)}`,
+    );
+  }
+  return name;
+}
+
+export function mcpServerFromV0Entry(
+  entry: types.V0ServerJsonEntry,
+): types.McpServer {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry))
+    throw new Error("v0 server.json entry must be an object");
+
+  const record = normalizeServerEntry(entry);
+  if (!record)
+    throw new Error("v0 server.json entry must be an object");
+
+  const transport = pickTransport(record);
+  const command = pickString(record, ["command", "cmd"]);
+  const url = pickString(record, ["url", "endpoint"]);
+
+  if (transport === "stdio" || command) {
+    if (!command) throw new Error("stdio MCP server entry is missing command");
+
+    return compactObject({
+      transport: "stdio",
+      command,
+      args: asStringArray(record.args),
+      env: asStringRecord(record.env),
+      cwd: pickString(record, ["cwd"]),
+    }) as types.McpServer;
+  }
+
+  if (transport === "http" || transport === "sse" || url) {
+    if (!url) throw new Error("HTTP MCP server entry is missing url");
+
+    return compactObject({
+      transport: transport === "sse" ? "sse" : "http",
+      url,
+      headers: asStringRecord(record.headers),
+    }) as types.McpServer;
+  }
+
+  throw new Error(
+    `Could not determine MCP server transport from v0 server.json entry:\n${JSON.stringify(entry, null, 2)}`,
+  );
+}
+
+export function mcpServersFromServerJson(serverJson: types.ServerJson) {
+  const entries = serverJson.mcpServers ?? serverJson.servers ?? {};
+  return Object.fromEntries(
+    Object.entries(entries).map(([name, entry]) => [name, mcpServerFromV0Entry(entry)]),
+  ) satisfies Record<string, types.McpServer>;
+}
+
+type PluginBuildResult = {
+  mcpJson: types.McpJson;
+  pluginJson: types.PluginJson;
+  marketplaceEntry: types.MarketplacePluginJson;
+};
+
+async function buildPlugin(
+  client: ApiCenterClient,
+  plugin: types.PluginAsset,
+): Promise<PluginBuildResult> {
+  const pluginName = sanitizeName(plugin.name);
+  const mcpServers: Record<string, types.McpServer> = {};
+
+  for (const resource of plugin.resources) {
+    if (resource.kind !== "mcp") continue;
+
+    const mcpAsset = await client.mcp(resource.resourceId);
+    const serverEntry = await client.v0Server(mcpAsset.name);
+    mcpServers[mcpServerNameFromV0Entry(serverEntry)] = mcpServerFromV0Entry(serverEntry);
+  }
+
+  const skills: string[] = [];
+  const pluginJson: types.PluginJson = {
+    name: plugin.name,
+    description: plugin.description || plugin.summary,
+    version: plugin.version,
+  };
+
+  if (Object.keys(mcpServers).length > 0)
+    pluginJson.mcpServers = ".mcp.json";
+
+  if (skills.length > 0)
+    pluginJson.skills = ["./skills/"];
+
+  return {
+    mcpJson: { mcpServers },
+    pluginJson,
+    marketplaceEntry: {
+      name: plugin.name,
+      version: plugin.version,
+      description: plugin.description || plugin.summary,
+      source: `plugins/${pluginName}`,
+      skills,
+    },
+  };
+}
+
+async function writeJson(path: string, value: unknown) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+async function zipDirectory(sourceDir: string, outputPath: string) {
+  await execFileAsync("zip", ["-rq", outputPath, "."], { cwd: sourceDir });
+}
+
+async function pathExists(path: string) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export type GenerateMarketplaceGitOptions = {
+  unpack?: string;
+};
+
+export async function generateMarketplaceGit(
+  info: types.WorkspaceInfo,
+  options: GenerateMarketplaceGitOptions = {},
+) {
+  const client = new ApiCenterClient(info);
+  const config = await client.config();
+  const tempRoot = await mkdtemp(join(tmpdir(), "gen-apic-mp-"));
+  const marketplaceRoot = join(tempRoot, "marketplace");
+  const marketplacePlugins: types.MarketplacePluginJson[] = [];
+
+  try {
+    for await (const page of client.apis()) {
+      for (const item of page) {
+        if (item.kind !== "plugin") continue;
+
+        const pluginAsset = await client.plugin(item.name);
+        const built = await buildPlugin(client, pluginAsset);
+        const pluginDir = join(marketplaceRoot, "plugins", sanitizeName(pluginAsset.name));
+
+        marketplacePlugins.push(built.marketplaceEntry);
+        await writeJson(join(pluginDir, "plugin.json"), built.pluginJson);
+        await writeJson(join(pluginDir, ".mcp.json"), built.mcpJson);
+      }
+    }
+
+    const marketplaceJson: types.MarketplaceJson = {
+      name: config.title,
+      metadata: {
+        description: `MCP server plugins from ${config.title}`,
+        version: "1.0.0",
+      },
+      owner: {
+        name: config.title,
+      },
+      plugins: marketplacePlugins,
+    };
+
+    await writeJson(join(marketplaceRoot, ".github", "plugin", "marketplace.json"), marketplaceJson);
+    await writeJson(join(marketplaceRoot, ".claude-plugin", "marketplace.json"), marketplaceJson);
+
+    const unpackPath = options.unpack ? resolve(options.unpack) : undefined;
+    if (unpackPath) {
+      await mkdir(unpackPath, { recursive: true });
+      await cp(marketplaceRoot, unpackPath, { recursive: true, force: true });
+    }
+    const zipPath = unpackPath
+      ? undefined
+      : join(process.cwd(), `${sanitizeName(info.workspaceName)}-marketplace.zip`);
+    if (zipPath) {
+      await rm(zipPath, { force: true });
+      await zipDirectory(marketplaceRoot, zipPath);
+    }
+
+    const marketplacePreview = await readFile(
+      join(marketplaceRoot, ".github", "plugin", "marketplace.json"),
+      "utf8",
+    );
+
+    return {
+      zipPath,
+      unpackPath,
+      pluginCount: marketplacePlugins.length,
+      marketplaceJson: JSON.parse(marketplacePreview) as types.MarketplaceJson,
+    };
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+const currentWorkingPackageSentinel = "__CURRENT_WORKING_PACKAGE__";
+
+export async function resolveUnpackDirectory(value: string | undefined) {
+  if (!value) return undefined;
+
+  if (value === currentWorkingPackageSentinel) {
+    const packageJsonPath = join(process.cwd(), "package.json");
+    if (!await pathExists(packageJsonPath)) {
+      throw new Error(
+        `--unpack without a path defaults to the current directory, but no package.json was found at ${packageJsonPath}`,
+      );
+    }
+
+    return process.cwd();
+  }
+
+  return resolve(value);
+}

package/src/shared/index.ts

@@ -0,0 +1 @@
+export * as types from './types.js';

package/src/shared/types.ts

@@ -0,0 +1,164 @@
+export type WorkspaceInfo = {
+  serviceName: string;
+  region: string;
+  workspaceName: string;
+};
+
+export type PortalConfig = {
+  dataApiHostName: string;
+  title: string;
+  capabilities: [];
+};
+
+export type JsonObject = Record<string, unknown>;
+
+export type McpAssetItem = {
+  name: string;
+  title: string;
+  summary: string;
+  description: string;
+  kind: 'mcp';
+  lifecycleStage: string;
+  externalDocumentation: [];
+  contacts: [];
+  customProperties: JsonObject;
+  lastUpdated: string;
+};
+
+export type PluginAssetItem = {
+  name: string;
+  title: string;
+  description: string;
+  kind: 'plugin';
+  lifecycleStage: string;
+  externalDocumentation: [];
+  contacts: [];
+  customProperties: JsonObject;
+  lastUpdated: string;
+};
+
+export type ApiAssetItem =
+  | McpAssetItem
+  | PluginAssetItem;
+
+export type PluginMcpResource = {
+  resourceId: string;
+  title: string;
+  summary: string;
+  kind: 'mcp';
+};
+
+export type PluginResource =
+  | PluginMcpResource;
+
+export type PluginAsset = {
+  name: string;
+  title: string;
+  summary: string;
+  description: string;
+  version: string;
+  resources: PluginResource[];
+  customProperties?: JsonObject;
+};
+
+export type PagedResponse<T> = {
+  value: T[];
+  nextLink?: string;
+};
+
+export type PlaneType = 'portal' | 'data';
+
+export type V0HttpTransport = {
+  transport?: 'http' | 'https' | 'sse' | 'streamable-http';
+  type?: 'http' | 'https' | 'sse' | 'streamable-http';
+  url: string;
+  headers?: Record<string, string>;
+};
+
+export type V0StdioTransport = {
+  transport?: 'stdio';
+  type?: 'stdio';
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+};
+
+export type V0ServerJsonEntry =
+  | V0HttpTransport
+  | V0StdioTransport
+  | JsonObject;
+
+export type ServerJson = {
+  mcpServers?: Record<string, V0ServerJsonEntry>;
+  servers?: Record<string, V0ServerJsonEntry>;
+};
+
+export type V0ServerEntryResponse = V0ServerJsonEntry;
+
+export type McpServerStdio = {
+  transport: 'stdio';
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+  cwd?: string;
+};
+
+export type McpServerHttp = {
+  transport: 'http' | 'sse';
+  url: string;
+  headers?: Record<string, string>;
+};
+
+export type McpServer = (McpServerStdio | McpServerHttp) & JsonObject;
+
+export type McpJson = {
+  mcpServers: Record<string, McpServer>;
+};
+
+export type PluginJson = {
+  name: string;
+  description: string;
+  version: string;
+  mcpServers?: string;
+  skills?: string[];
+};
+
+export type MarketplacePluginJson = {
+  name: string;
+  version: string;
+  description: string;
+  source: string | {
+    source: string;
+    repo: string;
+    path: string;
+  };
+  author?: {
+    name: string;
+    url: string;
+  };
+  homepage?: string;
+  keywords?: string[];
+  license?: string;
+  repository?: string;
+  skills: string[];
+};
+
+export type MarketplaceJson = {
+  name: string;
+  metadata: {
+    description: string;
+    version: string;
+  };
+  owner: {
+    name: string;
+    email?: string;
+  };
+  plugins: MarketplacePluginJson[];
+};
+
+export type McpAsset = McpAssetItem & {
+  version?: string;
+  serverJson?: ServerJson;
+  customProperties: JsonObject;
+};

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.tsbuildinfo",
+    "target": "ES2023",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "src"
+  ]
+}