@nkmc/cli 0.3.3 → 0.3.4

package/dist/dist-NYTRZS3R.js

@@ -0,0 +1,625 @@
+#!/usr/bin/env node
+
+// ../../node_modules/.pnpm/@shipkey+core@0.1.0/node_modules/@shipkey/core/dist/index.js
+import { execFile } from "child_process";
+function exec(cmd, args, env) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      cmd,
+      args,
+      { maxBuffer: 10 * 1024 * 1024, env: env ?? process.env },
+      (err, stdout, stderr) => {
+        if (err)
+          reject(new Error(`${cmd} failed: ${stderr?.trim() || err.message}`));
+        else resolve(stdout.trim());
+      }
+    );
+  });
+}
+async function exec2(args) {
+  return exec("op", args, {
+    ...process.env,
+    OP_BIOMETRIC_UNLOCK_ENABLED: "true"
+  });
+}
+var OnePasswordBackend = class {
+  name = "1Password";
+  sectionName(project, env) {
+    return `${project}-${env}`;
+  }
+  buildRef(ref) {
+    const section = this.sectionName(ref.project, ref.env);
+    return `op://${ref.vault}/${ref.provider}/${section}/${ref.field}`;
+  }
+  buildInlineRef(ref) {
+    return this.buildRef(ref);
+  }
+  buildWriteArgs(entry) {
+    const { ref, value } = entry;
+    const section = this.sectionName(ref.project, ref.env);
+    const fieldKey = `${section}.${ref.field}`;
+    return [
+      "item",
+      "edit",
+      ref.provider,
+      "--vault",
+      ref.vault,
+      `${fieldKey}[password]=${value}`
+    ];
+  }
+  async isAvailable() {
+    const status = await this.checkStatus();
+    return status === "ready";
+  }
+  async checkStatus() {
+    try {
+      await exec2(["--version"]);
+    } catch {
+      return "not_installed";
+    }
+    try {
+      const output = await exec2(["account", "list", "--format=json"]);
+      const accounts = JSON.parse(output);
+      if (!Array.isArray(accounts) || accounts.length === 0) {
+        return "not_logged_in";
+      }
+      return "ready";
+    } catch {
+      return "not_logged_in";
+    }
+  }
+  async read(ref) {
+    return exec2(["read", this.buildRef(ref)]);
+  }
+  async readRaw(opUri) {
+    return exec2(["read", opUri]);
+  }
+  async listVaultItems(vault) {
+    try {
+      const raw = await exec2([
+        "item",
+        "list",
+        "--vault",
+        vault,
+        "--format",
+        "json"
+      ]);
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  async getItemFields(provider, vault) {
+    try {
+      const raw = await exec2([
+        "item",
+        "get",
+        provider,
+        "--vault",
+        vault,
+        "--format",
+        "json"
+      ]);
+      const item = JSON.parse(raw);
+      if (!item.fields) return [];
+      return item.fields.filter((f) => f.section?.label && f.label).map((f) => ({
+        section: f.section.label,
+        label: f.label
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async ensureVault(vault) {
+    try {
+      await exec2(["vault", "get", vault]);
+    } catch {
+      await exec2(["vault", "create", vault, "--icon", "vault-door"]);
+    }
+  }
+  async write(entry) {
+    const { ref, value } = entry;
+    const section = this.sectionName(ref.project, ref.env);
+    const fieldKey = `${section}.${ref.field}`;
+    await this.ensureVault(ref.vault);
+    try {
+      await exec2([
+        "item",
+        "edit",
+        ref.provider,
+        "--vault",
+        ref.vault,
+        `${fieldKey}[password]=${value}`
+      ]);
+    } catch {
+      await exec2([
+        "item",
+        "create",
+        "--vault",
+        ref.vault,
+        "--category",
+        "API Credential",
+        "--title",
+        ref.provider,
+        `${fieldKey}[password]=${value}`
+      ]);
+    }
+  }
+  async list(project, env, vault = "shipkey") {
+    const raw = await exec2([
+      "item",
+      "list",
+      "--vault",
+      vault,
+      "--format",
+      "json"
+    ]);
+    const items = JSON.parse(raw);
+    const refs = [];
+    for (const item of items) {
+      const detail = await exec2([
+        "item",
+        "get",
+        item.id,
+        "--format",
+        "json"
+      ]);
+      const parsed = JSON.parse(detail);
+      if (!parsed.fields) continue;
+      for (const field of parsed.fields) {
+        if (!field.section?.label) continue;
+        const sectionLabel = field.section.label;
+        const dashIndex = sectionLabel.lastIndexOf("-");
+        if (dashIndex === -1) continue;
+        const proj = sectionLabel.slice(0, dashIndex);
+        const e = sectionLabel.slice(dashIndex + 1);
+        if (project && proj !== project) continue;
+        if (env && e !== env) continue;
+        refs.push({
+          vault,
+          provider: item.title,
+          project: proj,
+          env: e,
+          field: field.label
+        });
+      }
+    }
+    return refs;
+  }
+};
+async function exec3(args) {
+  return exec("bw", args);
+}
+var FIELD_TYPE_HIDDEN = 1;
+var BitwardenBackend = class _BitwardenBackend {
+  name = "Bitwarden";
+  sectionName(project, env) {
+    return `${project}-${env}`;
+  }
+  /** Encode a field name for storage as a custom field: "project-env.FIELD_NAME" */
+  buildFieldName(ref) {
+    const section = this.sectionName(ref.project, ref.env);
+    return `${section}.${ref.field}`;
+  }
+  /** Parse a custom field name back into project, env, field */
+  static parseFieldName(fieldName) {
+    const dotIndex = fieldName.indexOf(".");
+    if (dotIndex === -1) return null;
+    const section = fieldName.slice(0, dotIndex);
+    const field = fieldName.slice(dotIndex + 1);
+    const dashIndex = section.lastIndexOf("-");
+    if (dashIndex === -1) return null;
+    return {
+      project: section.slice(0, dashIndex),
+      env: section.slice(dashIndex + 1),
+      field
+    };
+  }
+  buildInlineRef() {
+    return null;
+  }
+  async isAvailable() {
+    const status = await this.checkStatus();
+    return status === "ready";
+  }
+  async checkStatus() {
+    try {
+      await exec3(["--version"]);
+    } catch {
+      return "not_installed";
+    }
+    try {
+      const output = await exec3(["status"]);
+      const status = JSON.parse(output);
+      if (status.status === "unauthenticated") {
+        return "not_logged_in";
+      }
+      if (status.status === "locked") {
+        return "not_logged_in";
+      }
+      return "ready";
+    } catch {
+      return "not_logged_in";
+    }
+  }
+  async ensureUnlocked() {
+    const output = await exec3(["status"]);
+    const status = JSON.parse(output);
+    if (status.status === "locked") {
+      throw new Error("Bitwarden vault is locked. Run: bw unlock");
+    }
+    if (status.status === "unauthenticated") {
+      throw new Error("Bitwarden CLI not logged in. Run: bw login");
+    }
+  }
+  async findOrCreateFolder(name) {
+    const foldersRaw = await exec3(["list", "folders"]);
+    const folders = JSON.parse(foldersRaw);
+    const existing = folders.find((f) => f.name === name);
+    if (existing) return existing.id;
+    const templateRaw = await exec3(["get", "template", "folder"]);
+    const template = JSON.parse(templateRaw);
+    template.name = name;
+    const encodedFolder = Buffer.from(JSON.stringify(template)).toString(
+      "base64"
+    );
+    const created = await exec3(["create", "folder", encodedFolder]);
+    const folder = JSON.parse(created);
+    return folder.id;
+  }
+  async findItem(provider, folderId) {
+    try {
+      const raw = await exec3([
+        "list",
+        "items",
+        "--folderid",
+        folderId,
+        "--search",
+        provider
+      ]);
+      const items = JSON.parse(raw);
+      return items.find((i) => i.name === provider) || null;
+    } catch {
+      return null;
+    }
+  }
+  async read(ref) {
+    await this.ensureUnlocked();
+    const folderId = await this.findOrCreateFolder(ref.vault);
+    const item = await this.findItem(ref.provider, folderId);
+    if (!item) {
+      throw new Error(
+        `Item "${ref.provider}" not found in folder "${ref.vault}"`
+      );
+    }
+    const fieldName = this.buildFieldName(ref);
+    const field = item.fields?.find((f) => f.name === fieldName);
+    if (!field) {
+      throw new Error(
+        `Field "${fieldName}" not found in item "${ref.provider}"`
+      );
+    }
+    return field.value;
+  }
+  async write(entry) {
+    await this.ensureUnlocked();
+    const { ref, value } = entry;
+    const folderId = await this.findOrCreateFolder(ref.vault);
+    const fieldName = this.buildFieldName(ref);
+    const existingItem = await this.findItem(ref.provider, folderId);
+    if (existingItem) {
+      const fields = existingItem.fields || [];
+      const existingFieldIndex = fields.findIndex(
+        (f) => f.name === fieldName
+      );
+      if (existingFieldIndex !== -1) {
+        fields[existingFieldIndex].value = value;
+      } else {
+        fields.push({
+          name: fieldName,
+          value,
+          type: FIELD_TYPE_HIDDEN
+        });
+      }
+      existingItem.fields = fields;
+      const encoded = Buffer.from(JSON.stringify(existingItem)).toString(
+        "base64"
+      );
+      await exec3(["edit", "item", existingItem.id, encoded]);
+    } else {
+      const templateRaw = await exec3(["get", "template", "item"]);
+      const template = JSON.parse(templateRaw);
+      template.type = 2;
+      template.secureNote = { type: 0 };
+      template.name = ref.provider;
+      template.folderId = folderId;
+      template.fields = [
+        {
+          name: fieldName,
+          value,
+          type: FIELD_TYPE_HIDDEN
+        }
+      ];
+      const encoded = Buffer.from(JSON.stringify(template)).toString("base64");
+      await exec3(["create", "item", encoded]);
+    }
+  }
+  async list(project, env, vault = "shipkey") {
+    await this.ensureUnlocked();
+    const foldersRaw = await exec3(["list", "folders"]);
+    const folders = JSON.parse(foldersRaw);
+    const folder = folders.find((f) => f.name === vault);
+    if (!folder) return [];
+    const itemsRaw = await exec3([
+      "list",
+      "items",
+      "--folderid",
+      folder.id
+    ]);
+    const items = JSON.parse(itemsRaw);
+    const refs = [];
+    for (const item of items) {
+      if (!item.fields) continue;
+      for (const field of item.fields) {
+        const parsed = _BitwardenBackend.parseFieldName(field.name);
+        if (!parsed) continue;
+        if (project && parsed.project !== project) continue;
+        if (env && parsed.env !== env) continue;
+        refs.push({
+          vault,
+          provider: item.name,
+          project: parsed.project,
+          env: parsed.env,
+          field: parsed.field
+        });
+      }
+    }
+    return refs;
+  }
+};
+var BACKENDS = {
+  "1password": () => new OnePasswordBackend(),
+  bitwarden: () => new BitwardenBackend()
+};
+function getBackend(name = "1password") {
+  const factory = BACKENDS[name];
+  if (!factory) {
+    throw new Error(
+      `Unknown backend: ${name}. Available: ${Object.keys(BACKENDS).join(", ")}`
+    );
+  }
+  return factory();
+}
+function listBackends() {
+  return Object.keys(BACKENDS);
+}
+var PROVIDERS = [
+  // --- AI ---
+  {
+    name: "OpenRouter",
+    patterns: [/OPENROUTER/i],
+    guide_url: "https://openrouter.ai/keys",
+    guide: "OpenRouter \u2192 Keys \u2192 Create Key"
+  },
+  {
+    name: "OpenAI",
+    patterns: [/OPENAI/i],
+    guide_url: "https://platform.openai.com/api-keys",
+    guide: "OpenAI Platform \u2192 API Keys \u2192 Create new secret key"
+  },
+  {
+    name: "Anthropic",
+    patterns: [/ANTHROPIC/i, /CLAUDE_API/i],
+    guide_url: "https://console.anthropic.com/settings/keys",
+    guide: "Anthropic Console \u2192 Settings \u2192 API Keys \u2192 Create Key"
+  },
+  {
+    name: "Google AI",
+    patterns: [/GEMINI/i, /GOOGLE_AI/i, /GOOGLE_GENERATIVE/i],
+    guide_url: "https://aistudio.google.com/apikey",
+    guide: "Google AI Studio \u2192 Get API key \u2192 Create API key"
+  },
+  {
+    name: "Replicate",
+    patterns: [/REPLICATE/i],
+    guide_url: "https://replicate.com/account/api-tokens",
+    guide: "Replicate \u2192 Account \u2192 API Tokens"
+  },
+  {
+    name: "Hugging Face",
+    patterns: [/HUGGING_?FACE/i, /^HF_/i],
+    guide_url: "https://huggingface.co/settings/tokens",
+    guide: "Hugging Face \u2192 Settings \u2192 Access Tokens \u2192 New token"
+  },
+  {
+    name: "fal.ai",
+    patterns: [/FAL/i],
+    guide_url: "https://fal.ai/dashboard/keys",
+    guide: "fal.ai \u2192 Dashboard \u2192 Keys"
+  },
+  // --- Payments ---
+  {
+    name: "Stripe",
+    patterns: [/STRIPE/i],
+    guide_url: "https://dashboard.stripe.com/apikeys",
+    guide: "Stripe Dashboard \u2192 Developers \u2192 API Keys"
+  },
+  // --- Social / OAuth ---
+  {
+    name: "GitHub OAuth",
+    patterns: [/GITHUB/i],
+    guide_url: "https://github.com/settings/developers",
+    guide: "GitHub \u2192 Settings \u2192 Developer settings \u2192 OAuth Apps"
+  },
+  {
+    name: "Reddit",
+    patterns: [/REDDIT/i],
+    guide_url: "https://www.reddit.com/prefs/apps",
+    guide: "Reddit \u2192 Preferences \u2192 Apps \u2192 Create app"
+  },
+  {
+    name: "Product Hunt",
+    patterns: [/PRODUCTHUNT/i, /PRODUCT_HUNT/i, /^PH_/i],
+    guide_url: "https://www.producthunt.com/v2/oauth/applications",
+    guide: "Product Hunt \u2192 API Dashboard \u2192 Add an Application"
+  },
+  {
+    name: "Discord",
+    patterns: [/DISCORD/i],
+    guide_url: "https://discord.com/developers/applications",
+    guide: "Discord Developer Portal \u2192 Applications \u2192 Bot \u2192 Token"
+  },
+  {
+    name: "Slack",
+    patterns: [/SLACK/i],
+    guide_url: "https://api.slack.com/apps",
+    guide: "Slack API \u2192 Your Apps \u2192 Create New App \u2192 OAuth Tokens"
+  },
+  {
+    name: "Google",
+    patterns: [/GOOGLE/i, /^GCP_/i, /^GCLOUD_/i],
+    guide_url: "https://console.cloud.google.com/apis/credentials",
+    guide: "Google Cloud Console \u2192 APIs & Services \u2192 Credentials"
+  },
+  // --- Auth ---
+  {
+    name: "Clerk",
+    patterns: [/CLERK/i],
+    guide_url: "https://dashboard.clerk.com",
+    guide: "Clerk Dashboard \u2192 API Keys"
+  },
+  {
+    name: "Auth0",
+    patterns: [/AUTH0/i],
+    guide_url: "https://manage.auth0.com/dashboard",
+    guide: "Auth0 Dashboard \u2192 Applications \u2192 Settings"
+  },
+  // --- Communication ---
+  {
+    name: "Twilio",
+    patterns: [/TWILIO/i],
+    guide_url: "https://console.twilio.com",
+    guide: "Twilio Console \u2192 Account \u2192 API keys & tokens"
+  },
+  {
+    name: "SendGrid",
+    patterns: [/SENDGRID/i],
+    guide_url: "https://app.sendgrid.com/settings/api_keys",
+    guide: "SendGrid \u2192 Settings \u2192 API Keys \u2192 Create API Key"
+  },
+  {
+    name: "Resend",
+    patterns: [/RESEND/i],
+    guide_url: "https://resend.com/api-keys",
+    guide: "Resend \u2192 API Keys \u2192 Create API Key"
+  },
+  // --- Databases ---
+  {
+    name: "Supabase",
+    patterns: [/SUPABASE/i],
+    guide_url: "https://supabase.com/dashboard/project/_/settings/api",
+    guide: "Supabase \u2192 Project Settings \u2192 API"
+  },
+  {
+    name: "Turso",
+    patterns: [/TURSO/i],
+    guide_url: "https://turso.tech/app",
+    guide: "Turso \u2192 Dashboard \u2192 Database \u2192 Create Token"
+  },
+  {
+    name: "Upstash",
+    patterns: [/UPSTASH/i],
+    guide_url: "https://console.upstash.com",
+    guide: "Upstash Console \u2192 Database \u2192 REST API credentials"
+  },
+  {
+    name: "Neon",
+    patterns: [/NEON/i],
+    guide_url: "https://console.neon.tech",
+    guide: "Neon Console \u2192 Project \u2192 Connection Details"
+  },
+  {
+    name: "Database",
+    patterns: [/DATABASE/i, /^DB_/i]
+  },
+  {
+    name: "Redis",
+    patterns: [/REDIS/i]
+  },
+  // --- Infrastructure ---
+  {
+    name: "Cloudflare",
+    patterns: [/CLOUDFLARE/i],
+    guide_url: "https://dash.cloudflare.com/profile/api-tokens",
+    guide: "Cloudflare Dashboard \u2192 Profile \u2192 API Tokens \u2192 Create Token"
+  },
+  {
+    name: "npm",
+    patterns: [/^NPM/i],
+    guide_url: "https://www.npmjs.com/settings/~/tokens",
+    guide: "npmjs.com \u2192 Access Tokens \u2192 Generate New Token (Classic) \u2192 Publish"
+  },
+  {
+    name: "AWS",
+    patterns: [/^AWS/i],
+    guide_url: "https://console.aws.amazon.com/iam/",
+    guide: "AWS Console \u2192 IAM \u2192 Users \u2192 Security credentials"
+  },
+  {
+    name: "Vercel",
+    patterns: [/VERCEL/i],
+    guide_url: "https://vercel.com/account/tokens",
+    guide: "Vercel \u2192 Account Settings \u2192 Tokens"
+  },
+  {
+    name: "Fly",
+    patterns: [/FLY/i],
+    guide_url: "https://fly.io/user/personal_access_tokens",
+    guide: "Fly.io \u2192 Account \u2192 Access Tokens"
+  },
+  {
+    name: "Sentry",
+    patterns: [/SENTRY/i],
+    guide_url: "https://sentry.io/settings/account/api/auth-tokens/",
+    guide: "Sentry \u2192 Settings \u2192 Auth Tokens \u2192 Create New Token"
+  },
+  // --- Misc ---
+  {
+    name: "Session",
+    patterns: [/SESSION/i]
+  }
+];
+function guessProvider(key) {
+  for (const provider of PROVIDERS) {
+    if (provider.patterns.some((p) => p.test(key))) {
+      return provider.name;
+    }
+  }
+  return "General";
+}
+function groupByProvider(envKeys) {
+  const result = {};
+  for (const key of envKeys) {
+    const providerName = guessProvider(key);
+    if (!result[providerName]) {
+      const def = PROVIDERS.find((p) => p.name === providerName);
+      result[providerName] = {
+        fields: [],
+        ...def?.guide_url && { guide_url: def.guide_url },
+        ...def?.guide && { guide: def.guide }
+      };
+    }
+    result[providerName].fields.push(key);
+  }
+  return result;
+}
+export {
+  BitwardenBackend,
+  OnePasswordBackend,
+  PROVIDERS,
+  exec,
+  getBackend,
+  groupByProvider,
+  guessProvider,
+  listBackends
+};

package/dist/index.js

@@ -14,7 +14,9 @@ import {
 } from "./chunk-ZFNDBUPR.js";
 
 // src/index.ts
-import { createRequire } from "module";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname as dirname2, resolve } from "path";
 import { Command } from "commander";
 
 // src/scanner/detect.ts
@@ -983,8 +985,8 @@ async function syncToGateway(domain, auth) {
 }
 
 // src/index.ts
-var require2 = createRequire(import.meta.url);
-var { version } = require2("../../package.json");
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var { version } = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf-8"));
 var program = new Command();
 program.name("nkmc").description("nkmc SDK CLI").version(version);
 program.command("init").description("Initialize nkmc in the current project").argument("[dir]", "Project directory", ".").action(async (dir) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkmc/cli",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "CLI for scanning and registering APIs with the nkmc gateway",
   "license": "MIT",
   "type": "module",
@@ -17,6 +17,9 @@
     "commander": "^13.0.0",
     "ts-morph": "^27.0.2"
   },
+  "optionalDependencies": {
+    "@shipkey/core": "^0.1.0"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/chekusu/nkmc-sdk.git",