@bulkgrid/cli 0.1.0

package/dist/chunk-OUGLFLZG.js

@@ -0,0 +1,351 @@
+// src/init.ts
+import { spawnSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { checkbox, confirm, input, password, select } from "@inquirer/prompts";
+var DEFAULT_SERVER_NAME = "bulkgrid";
+var API_KEY_ENV_VAR = "BULKGRID_API_KEY";
+var MCP_URL_ENV_VAR = "BULKGRID_MCP_URL";
+var DASHBOARD_API_KEYS_URL = "https://bulkgrid.com/dashboard/settings/api-keys";
+var AGENT_CHOICES = [
+  { label: "Cursor", value: "cursor" },
+  { label: "VS Code", value: "vscode" },
+  { label: "Claude Code", value: "claude" },
+  { label: "Codex", value: "codex" }
+];
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonObject(filePath) {
+  if (!existsSync(filePath)) {
+    return {};
+  }
+  const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+  if (!isJsonObject(parsed)) {
+    throw new Error(`${filePath} must contain a JSON object`);
+  }
+  return parsed;
+}
+function writeJsonFile(filePath, data) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, `${JSON.stringify(data, null, 2)}
+`);
+}
+function getObjectProperty(parent, key) {
+  const current = parent[key];
+  if (isJsonObject(current)) {
+    return current;
+  }
+  const next = {};
+  parent[key] = next;
+  return next;
+}
+function buildAuthorizationHeader(context, inputExpression) {
+  if (context.writeApiKey && context.apiKey) {
+    return `Bearer ${context.apiKey}`;
+  }
+  return `Bearer ${inputExpression}`;
+}
+function buildCursorServer(context) {
+  return {
+    url: context.mcpUrl,
+    headers: {
+      Authorization: buildAuthorizationHeader(context, `\${env:${API_KEY_ENV_VAR}}`)
+    }
+  };
+}
+function mergeCursorConfig(existing, context) {
+  const next = { ...existing };
+  const servers = getObjectProperty(next, "mcpServers");
+  servers[DEFAULT_SERVER_NAME] = buildCursorServer(context);
+  return next;
+}
+function buildVsCodeConfig(context) {
+  return {
+    inputs: [
+      {
+        type: "promptString",
+        id: "bulkgrid-api-key",
+        description: "Bulkgrid API Key",
+        password: true
+      }
+    ],
+    servers: {
+      [DEFAULT_SERVER_NAME]: {
+        type: "http",
+        url: context.mcpUrl,
+        headers: {
+          Authorization: buildAuthorizationHeader(context, "${input:bulkgrid-api-key}")
+        }
+      }
+    }
+  };
+}
+function mergeVsCodeConfig(existing, context) {
+  const next = { ...existing };
+  const config = buildVsCodeConfig(context);
+  const existingServers = getObjectProperty(next, "servers");
+  const configServers = getObjectProperty(config, "servers");
+  existingServers[DEFAULT_SERVER_NAME] = configServers[DEFAULT_SERVER_NAME] ?? {};
+  if (!Array.isArray(next.inputs)) {
+    next.inputs = config.inputs ?? [];
+    return next;
+  }
+  const hasInput = next.inputs.some((item) => isJsonObject(item) && item.id === "bulkgrid-api-key");
+  if (!hasInput && Array.isArray(config.inputs)) {
+    next.inputs = [...next.inputs, ...config.inputs];
+  }
+  return next;
+}
+function resolveCursorPath(scope) {
+  if (scope === "global") {
+    return join(homedir(), ".cursor", "mcp.json");
+  }
+  return join(process.cwd(), ".cursor", "mcp.json");
+}
+function resolveVsCodePath(scope) {
+  if (scope === "global") {
+    if (process.platform === "darwin") {
+      return join(homedir(), "Library", "Application Support", "Code", "User", "mcp.json");
+    }
+    if (process.platform === "win32") {
+      return join(homedir(), "AppData", "Roaming", "Code", "User", "mcp.json");
+    }
+    return join(homedir(), ".config", "Code", "User", "mcp.json");
+  }
+  return join(process.cwd(), ".vscode", "mcp.json");
+}
+function setupCursor(context) {
+  const filePath = resolveCursorPath(context.scope);
+  const config = mergeCursorConfig(parseJsonObject(filePath), context);
+  writeJsonFile(filePath, config);
+  return {
+    agent: "cursor",
+    status: "configured",
+    message: `Wrote ${filePath}`
+  };
+}
+function setupVsCode(context) {
+  const filePath = resolveVsCodePath(context.scope);
+  const config = mergeVsCodeConfig(parseJsonObject(filePath), context);
+  writeJsonFile(filePath, config);
+  return {
+    agent: "vscode",
+    status: "configured",
+    message: `Wrote ${filePath}`
+  };
+}
+function commandExists(command) {
+  const result = spawnSync(command, ["--version"], { encoding: "utf8", stdio: "ignore" });
+  return result.status === 0;
+}
+function runCommand(command, args) {
+  const result = spawnSync(command, args, { encoding: "utf8", stdio: "inherit" });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`${command} ${args.join(" ")} failed with exit code ${result.status ?? "unknown"}`);
+  }
+}
+function printInitBanner() {
+  console.log("");
+  console.log("  \u25A6 Bulkgrid init");
+  console.log("");
+}
+async function promptForConfirmation(message, defaultValue) {
+  return confirm({
+    message,
+    default: defaultValue
+  });
+}
+async function promptForSelect(message, choices) {
+  return select({
+    message,
+    choices: choices.map((choice) => ({
+      name: choice.label,
+      value: choice.value
+    }))
+  });
+}
+async function promptForMultiSelect(message, choices) {
+  return checkbox({
+    message,
+    choices: choices.map((choice) => ({
+      name: choice.label,
+      value: choice.value,
+      checked: true
+    })),
+    required: true,
+    pageSize: choices.length
+  });
+}
+async function maybeInstallGlobally(options) {
+  if (options.installGlobal) {
+    runCommand("npm", ["install", "-g", "@bulkgrid/cli"]);
+    return;
+  }
+  if (options.yes) {
+    return;
+  }
+  const shouldInstall = await promptForConfirmation("Install @bulkgrid/cli globally?", false);
+  if (shouldInstall) {
+    runCommand("npm", ["install", "-g", "@bulkgrid/cli"]);
+  }
+}
+function openBrowser(url) {
+  let command;
+  let args;
+  if (process.platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (process.platform === "win32") {
+    command = "cmd";
+    args = ["/c", "start", "", url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+  const result = spawnSync(command, args, { encoding: "utf8", stdio: "ignore" });
+  if (result.status !== 0) {
+    console.log(`Open ${url} to create a Bulkgrid API key.`);
+  }
+}
+async function resolveApiKey(options) {
+  const configuredApiKey = options.apiKey ?? process.env[API_KEY_ENV_VAR];
+  if (configuredApiKey || options.yes) {
+    return configuredApiKey;
+  }
+  const authMode = options.auth ?? await promptForSelect("Authenticate to Bulkgrid", [
+    { label: "Open the dashboard and paste a new API key", value: "browser" },
+    { label: "Enter an existing API key", value: "manual" },
+    { label: "Skip this step", value: "skip" }
+  ]);
+  if (authMode === "skip") {
+    console.log(`Skipped. Set ${API_KEY_ENV_VAR} later or use client-side prompts.`);
+    return void 0;
+  }
+  if (authMode === "browser") {
+    openBrowser(DASHBOARD_API_KEYS_URL);
+    console.log("Create an API key with mcp:use and search:query scopes.");
+  }
+  const apiKey = await password({
+    message: "Bulkgrid API key",
+    mask: "*",
+    validate: (value) => value.trim().length > 0 || "Enter a Bulkgrid API key."
+  });
+  return apiKey || void 0;
+}
+function setupCodex(context) {
+  if (!commandExists("codex")) {
+    return {
+      agent: "codex",
+      status: "skipped",
+      message: "codex command was not found"
+    };
+  }
+  runCommand("codex", ["mcp", "add", DEFAULT_SERVER_NAME, "--url", context.mcpUrl, "--bearer-token-env-var", API_KEY_ENV_VAR]);
+  return {
+    agent: "codex",
+    status: "configured",
+    message: `Registered ${DEFAULT_SERVER_NAME} with codex mcp add`
+  };
+}
+function setupClaude(context) {
+  if (!commandExists("claude")) {
+    return {
+      agent: "claude",
+      status: "skipped",
+      message: "claude command was not found"
+    };
+  }
+  if (!context.apiKey) {
+    return {
+      agent: "claude",
+      status: "skipped",
+      message: `Set ${API_KEY_ENV_VAR} or pass --api-key to configure Claude Code`
+    };
+  }
+  const args = ["mcp", "add", "--transport", "http"];
+  if (context.scope === "global") {
+    args.push("--scope", "user");
+  }
+  args.push(DEFAULT_SERVER_NAME, context.mcpUrl, "--header", `Authorization: Bearer ${context.apiKey}`);
+  runCommand("claude", args);
+  return {
+    agent: "claude",
+    status: "configured",
+    message: `Registered ${DEFAULT_SERVER_NAME} with claude mcp add`
+  };
+}
+async function resolveAgents(options) {
+  if (options.all || !options.cursor && !options.vscode && !options.claude && !options.codex) {
+    if (!options.all && !options.yes) {
+      const shouldConfigure = await promptForConfirmation("Configure the Bulkgrid MCP server for clients?", true);
+      if (!shouldConfigure) {
+        return [];
+      }
+      return promptForMultiSelect("Choose MCP clients to configure:", AGENT_CHOICES);
+    }
+    return ["cursor", "vscode", "claude", "codex"];
+  }
+  const agents = [];
+  if (options.cursor) {
+    agents.push("cursor");
+  }
+  if (options.vscode) {
+    agents.push("vscode");
+  }
+  if (options.claude) {
+    agents.push("claude");
+  }
+  if (options.codex) {
+    agents.push("codex");
+  }
+  return agents;
+}
+async function promptForValue(message) {
+  return input({
+    message,
+    validate: (value) => value.trim().length > 0 || "Enter a value."
+  });
+}
+async function buildContext(options) {
+  const configuredUrl = options.mcpUrl ?? process.env[MCP_URL_ENV_VAR];
+  const mcpUrl = configuredUrl ?? (options.yes ? void 0 : await promptForValue("Bulkgrid MCP URL: "));
+  if (!mcpUrl) {
+    throw new Error(`Missing MCP URL. Pass --mcp-url or set ${MCP_URL_ENV_VAR}.`);
+  }
+  const apiKey = await resolveApiKey(options);
+  const agents = await resolveAgents(options);
+  return {
+    agents,
+    mcpUrl,
+    apiKey,
+    scope: options.global ? "global" : "project",
+    writeApiKey: options.writeApiKey ?? false
+  };
+}
+async function runInitCommand(options) {
+  printInitBanner();
+  await maybeInstallGlobally(options);
+  const context = await buildContext(options);
+  const results = [];
+  for (const agent of context.agents) {
+    if (agent === "cursor") {
+      results.push(setupCursor(context));
+    } else if (agent === "vscode") {
+      results.push(setupVsCode(context));
+    } else if (agent === "claude") {
+      results.push(setupClaude(context));
+    } else if (agent === "codex") {
+      results.push(setupCodex(context));
+    }
+  }
+  return results;
+}
+
+export {
+  runInitCommand
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import {
+  runInitCommand
+} from "./chunk-OUGLFLZG.js";
+
+// src/cli.ts
+import { Command } from "commander";
+var program = new Command();
+program.name("bulkgrid").description("Bulkgrid developer tooling").version("0.1.0");
+program.command("init").description("Configure the Bulkgrid MCP server").option("--all", "configure all supported agents").option("--cursor", "configure Cursor").option("--vscode", "configure VS Code").option("--claude", "configure Claude Code").option("--codex", "configure Codex").option("--mcp-url <url>", "Bulkgrid MCP server URL").option("--api-key <key>", "Bulkgrid API key; defaults to BULKGRID_API_KEY").option("--global", "write global user configuration where supported").option("--project", "write project configuration where supported").option("--yes", "do not prompt for missing values").option("--write-api-key", "write the API key into generated JSON config files").option("--install-global", "install @bulkgrid/cli globally before configuring agents").option("--auth <mode>", "authentication mode: browser, manual, or skip").action(async (options) => {
+  try {
+    const results = await runInitCommand(options);
+    if (results.length === 0) {
+      console.log("No MCP clients configured.");
+      return;
+    }
+    for (const result of results) {
+      const marker = result.status === "configured" ? "configured" : "skipped";
+      console.log(`${result.agent}: ${marker} - ${result.message}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`bulkgrid init failed: ${message}`);
+    process.exitCode = 1;
+  }
+});
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+type AgentName = 'cursor' | 'vscode' | 'claude' | 'codex';
+type AuthMode = 'browser' | 'manual' | 'skip';
+interface InitFlags {
+    readonly all?: boolean;
+    readonly cursor?: boolean;
+    readonly vscode?: boolean;
+    readonly claude?: boolean;
+    readonly codex?: boolean;
+}
+interface InitCommandOptions extends InitFlags {
+    readonly mcpUrl?: string;
+    readonly apiKey?: string;
+    readonly global?: boolean;
+    readonly project?: boolean;
+    readonly yes?: boolean;
+    readonly writeApiKey?: boolean;
+    readonly installGlobal?: boolean;
+    readonly auth?: AuthMode;
+}
+interface SetupResult {
+    readonly agent: AgentName;
+    readonly status: 'configured' | 'skipped';
+    readonly message: string;
+}
+declare function runInitCommand(options: InitCommandOptions): Promise<readonly SetupResult[]>;
+
+export { type InitCommandOptions, runInitCommand };

package/dist/index.js

@@ -0,0 +1,6 @@
+import {
+  runInitCommand
+} from "./chunk-OUGLFLZG.js";
+export {
+  runInitCommand
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@bulkgrid/cli",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "bulkgrid": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "lint": "eslint .",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "format": "prettier --write \"src/**/*.{ts,js,md}\"",
+    "format:check": "prettier --check \"src/**/*.{ts,js,md}\""
+  },
+  "dependencies": {
+    "@inquirer/prompts": "7.10.1",
+    "commander": "14.0.3"
+  },
+  "devDependencies": {
+    "@repo/eslint-config": "*",
+    "@repo/typescript-config": "*",
+    "tsup": "8.5.1",
+    "vitest": "4.1.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}