@yhonda/gcloud-secrets 2.0.10 → 2.0.12

package/README.md

@@ -1,4 +1,4 @@
-# @yhonda/gcloud-secrets-mcp
+# @yhonda/gcloud-secrets
 
 複数の GCP プロジェクトの `.env` / `.dev.vars` を1つの Secret Manager で一元管理する CLI ツール。
 
@@ -8,11 +8,14 @@ Claude Code のスキルとしても利用可能。
 
 ```
 Secret Manager (中央プロジェクト)
-├── project-a/
+├── project-a/ [dev]
 │   ├── DATABASE_URL
 │   ├── API_KEY
 │   └── CLOUDFLARE_SECRET
-├── project-b/
+├── project-a/ [prod]
+│   ├── DATABASE_URL
+│   └── API_KEY
+├── project-b/ [dev]
 │   ├── DATABASE_URL
 │   └── STRIPE_KEY
 └── project-c/
@@ -22,13 +25,7 @@ Secret Manager (中央プロジェクト)
 ## インストール
 
 ```bash
-# ~/bin にインストール
-mkdir -p ~/bin && cd ~/bin
-npm install @yhonda/gcloud-secrets-mcp
-ln -sf ~/bin/node_modules/.bin/gcloud-secrets-mcp ~/bin/gcloud-secrets-mcp
-
-# PATH に追加 (~/.bashrc または ~/.zshrc)
-echo 'export PATH="$HOME/bin:$PATH"' >> ~/.bashrc
+npm install -g @yhonda/gcloud-secrets
 ```
 
 ### 前提条件
@@ -39,58 +36,100 @@ echo 'export PATH="$HOME/bin:$PATH"' >> ~/.bashrc
 ## 初期設定
 
 ```bash
-gcloud-secrets-mcp init <project-id>
+gcloud-secrets init <project-id> [--env <default-env>]
 ```
 
 設定は `~/.secrets-manager.conf` に保存されます。
 
-## CLI 使い方
+## CLI コマンド
+
+### 基本操作
 
 ```bash
-# フォルダ一覧
-gcloud-secrets-mcp list
+# フォルダ一覧（環境ごとにグループ化）
+gcloud-secrets list
 
 # フォルダ内のシークレット一覧
-gcloud-secrets-mcp list my-project
+gcloud-secrets list my-project --env dev
 
-# シークレットを取得（.env形式で標準出力）
-gcloud-secrets-mcp pull my-project
+# シークレットを取得（.env 形式で標準出力）
+gcloud-secrets pull my-project --env prod
 
 # シークレットをアップロード
-gcloud-secrets-mcp push my-project .env
+gcloud-secrets push my-project .env --env dev
 ```
 
-## Claude Code スキル
+### スキャン & 検索
 
-`~/.claude/commands/secrets.md` を作成すると `/secrets` コマンドが使えます:
+```bash
+# 全リポジトリの .env 同期状況をスキャン
+gcloud-secrets scan
+
+# 指定パス以下をスキャン（特定環境のみ）
+gcloud-secrets scan ~/projects --env dev
 
-```markdown
-# GCP Secret Manager スキル
+# 値から逆引き検索
+gcloud-secrets search "api-key-12345"
+```
 
-ユーザーの指示に従って以下のコマンドを実行:
+### 自動同期 (pre-commit hook)
 
-- `~/bin/gcloud-secrets-mcp list` - フォルダ一覧
-- `~/bin/gcloud-secrets-mcp list <folder>` - シークレット一覧
-- `~/bin/gcloud-secrets-mcp pull <folder>` - 取得
-- `~/bin/gcloud-secrets-mcp push <folder> <file>` - アップロード
+```bash
+# グローバル git hook をインストール（全リポジトリ対象）
+gcloud-secrets hook install
+
+# アンインストール
+gcloud-secrets hook uninstall
+
+# 手動実行
+gcloud-secrets pre-commit
 ```
 
-### 使用例
+`hook install` すると、全リポジトリで `git commit` のたびに `.env` が自動で Secret Manager に同期されます。
 
-Claude に以下のように依頼できます:
+**高速化の仕組み:**
+- キャッシュ (`~/.secrets-manager-cache.json`) で .env の変更を検知
+- 変更なし → **0 API コール**（即座に終了）
+- 変更あり → フィルタ付き API + 並列取得で高速チェック＆自動 push
+- 常に exit 0（commit をブロックしない）
+- 既存の `.husky/` や `.git/hooks/` と互換性あり
 
-- `/secrets list`
-- `/secrets pull my-project`
-- 「このプロジェクトの .env を Secret Manager にアップロードして」
+## 環境 (Environment)
+
+`--env` または `-e` で環境を指定できます:
+
+```bash
+gcloud-secrets push --env dev     # dev 環境にアップロード
+gcloud-secrets pull -e prod       # prod 環境から取得
+gcloud-secrets scan --env staging # staging のみスキャン
+```
+
+デフォルト環境は `~/.secrets-manager.conf` の `DEFAULT_ENVIRONMENT` で設定。
 
 ## コマンド一覧
 
 | コマンド | 説明 |
 |---------|------|
-| `init <project-id>` | 中央プロジェクトを設定 |
-| `list [folder]` | 一覧表示 |
-| `pull [folder]` | シークレットを取得 |
-| `push [folder] [file]` | アップロード |
+| `init <project-id> [--env <default>]` | 中央プロジェクトを設定 |
+| `list [folder] [--env <env>]` | 一覧表示 |
+| `pull [folder] [--env <env>]` | シークレットを取得 |
+| `push [folder] [file] [--env <env>]` | アップロード |
+| `scan [basePath] [--env <env>]` | Git リポジトリの同期状況をスキャン |
+| `search <keyword> [--env <env>]` | 値から逆引き検索 |
+| `pre-commit` | .env 自動同期（git hook 用） |
+| `hook install` | グローバル git hook をインストール |
+| `hook uninstall` | グローバル git hook をアンインストール |
+
+## フォルダ名の正規化
+
+ディレクトリ名は自動で kebab-case に変換されます:
+
+- `gcloudSec` → `gcloud-sec`
+- `myAppTest` → `my-app-test`
+
+## シークレット名の形式
+
+`{folder}_{env}_{KEY}` (例: `gcloud-sec_dev_DATABASE_URL`)
 
 ## 設定
 
@@ -102,8 +141,17 @@ export SECRETS_CENTRAL_PROJECT=your-project-id
 
 # または設定ファイル (~/.secrets-manager.conf)
 SECRETS_CENTRAL_PROJECT=your-project-id
+DEFAULT_ENVIRONMENT=dev
 ```
 
+## Claude Code スキル
+
+インストール時に `~/.claude/skills/secrets.md` が自動作成され、`/secrets` コマンドが使えます:
+
+- 「このプロジェクトの .env を Secret Manager にアップロードして」
+- 「dev 環境のシークレットを確認して」
+- 「全リポジトリの同期状況をスキャンして」
+
 ## ライセンス
 
 MIT

package/cli.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 import { SecretManagerServiceClient } from "@google-cloud/secret-manager";
-import { readFileSync, writeFileSync, existsSync, readdirSync, lstatSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, readdirSync, lstatSync, mkdirSync, chmodSync, rmSync } from "fs";
+import { createHash } from "crypto";
 import { basename, join, dirname, resolve } from "path";
 import { homedir } from "os";
 import { execSync } from "child_process";
@@ -146,6 +147,27 @@ function compareValues(a, b) {
   return a.trim().replace(/\r\n/g, '\n') === b.trim().replace(/\r\n/g, '\n');
 }
 
+// キャッシュ管理
+function getCachePath() {
+  return join(homedir(), '.secrets-manager-cache.json');
+}
+
+function readCache() {
+  const cachePath = getCachePath();
+  if (existsSync(cachePath)) {
+    try { return JSON.parse(readFileSync(cachePath, 'utf-8')); } catch { return {}; }
+  }
+  return {};
+}
+
+function writeCache(cache) {
+  writeFileSync(getCachePath(), JSON.stringify(cache, null, 2));
+}
+
+function hashContent(content) {
+  return createHash('md5').update(content).digest('hex');
+}
+
 // CLI モード
 async function runCli(args) {
   const parsed = parseArgs(args);
@@ -153,7 +175,7 @@ async function runCli(args) {
   const config = getConfig();
   const targetEnv = parsed.env || config.defaultEnvironment;
 
-  if (!config.centralProject && command !== "init") {
+  if (!config.centralProject && command !== "init" && command !== "pre-commit" && command !== "hook") {
     console.error("エラー: 先に init を実行してください");
     process.exit(1);
   }
@@ -408,6 +430,128 @@ async function runCli(args) {
         break;
       }
 
+      case "pre-commit": {
+        // config なし → サイレント exit
+        if (!config.centralProject) process.exit(0);
+
+        const cwd = process.cwd();
+        const folder = normalizeFolder(basename(resolve(cwd)));
+        const envFiles = findEnvFiles(cwd);
+        if (envFiles.length === 0) process.exit(0);
+
+        const cache = readCache();
+        const parent = `projects/${config.centralProject}`;
+        let totalPushed = 0;
+
+        for (const envFile of envFiles) {
+          let content;
+          try { content = readFileSync(envFile.path, 'utf-8'); } catch { continue; }
+          if (!content.trim()) continue;
+
+          const currentHash = hashContent(content);
+          const cacheKey = envFile.path;
+
+          // キャッシュヒット → スキップ (0 API コール)
+          if (cache[cacheKey] && cache[cacheKey].hash === currentHash) {
+            console.log(`✓ ${envFile.filename} synced`);
+            continue;
+          }
+
+          const localEntries = parseEnvFile(content);
+          if (localEntries.length === 0) continue;
+
+          const labels = { folder, environment: targetEnv };
+
+          try {
+            // フィルタ付き listSecrets (1 API コール、ラベル込み)
+            const filter = `labels.folder=${folder} AND labels.environment=${targetEnv}`;
+            const [remoteSecrets] = await client.listSecrets({ parent, filter });
+
+            // リモートキー → シークレット名マップ
+            const remoteMap = new Map();
+            for (const secret of remoteSecrets) {
+              const { key } = getKeyFromSecret(secret.name.split('/').pop(), folder);
+              remoteMap.set(key, secret.name);
+            }
+
+            // リモート値を並列取得
+            const remoteValues = new Map();
+            const keysToCompare = localEntries.filter(e => remoteMap.has(e.key));
+            if (keysToCompare.length > 0) {
+              const results = await Promise.all(
+                keysToCompare.map(async (entry) => {
+                  try {
+                    const [version] = await client.accessSecretVersion({
+                      name: `${remoteMap.get(entry.key)}/versions/latest`,
+                    });
+                    return { key: entry.key, value: version.payload.data.toString('utf-8') };
+                  } catch { return { key: entry.key, value: null }; }
+                })
+              );
+              for (const r of results) {
+                if (r.value !== null) remoteValues.set(r.key, r.value);
+              }
+            }
+
+            // 新規/変更キーを特定
+            const toPush = [];
+            for (const entry of localEntries) {
+              if (!remoteMap.has(entry.key)) {
+                toPush.push(entry);
+              } else if (!remoteValues.has(entry.key) || !compareValues(entry.value, remoteValues.get(entry.key))) {
+                toPush.push(entry);
+              }
+            }
+
+            // push
+            if (toPush.length > 0) {
+              for (const entry of toPush) {
+                const secretId = makeSecretName(folder, entry.key, targetEnv);
+                const secretName = `${parent}/secrets/${secretId}`;
+                try {
+                  await client.getSecret({ name: secretName });
+                  await client.updateSecret({
+                    secret: { name: secretName, labels },
+                    updateMask: { paths: ['labels'] }
+                  });
+                  await client.addSecretVersion({
+                    parent: secretName,
+                    payload: { data: Buffer.from(entry.value) },
+                  });
+                } catch {
+                  await client.createSecret({
+                    parent,
+                    secretId,
+                    secret: { replication: { automatic: {} }, labels },
+                  });
+                  await client.addSecretVersion({
+                    parent: secretName,
+                    payload: { data: Buffer.from(entry.value) },
+                  });
+                }
+              }
+              console.log(`↑ ${envFile.filename}: ${toPush.length} secrets pushed (${folder}/${targetEnv})`);
+              totalPushed += toPush.length;
+            } else {
+              console.log(`✓ ${envFile.filename} synced`);
+            }
+
+            // キャッシュ更新
+            cache[cacheKey] = {
+              hash: currentHash,
+              folder,
+              env: targetEnv,
+              syncedAt: new Date().toISOString()
+            };
+          } catch (error) {
+            console.log(`⚠ ${envFile.filename}: sync skipped (${error.message})`);
+          }
+        }
+
+        try { writeCache(cache); } catch { }
+        process.exit(0);
+      }
+
       case "search": {
         const keyword = parsed.positional[1];
         if (!keyword) {
@@ -423,32 +567,34 @@ async function runCli(args) {
         if (filterEnv) console.log(`  環境: ${filterEnv}`);
         console.log(`\nScanning ${secrets.length} secrets...\n`);
 
-        const matches = [];
-        const folders = new Set();
-
-        for (const secret of secrets) {
-          const [secretData] = await client.getSecret({ name: secret.name });
-          const folder = secretData.labels?.folder;
-          const env = secretData.labels?.environment || "(default)";
+        const results = await Promise.all(
+          secrets.map(async (secret) => {
+            try {
+              const [secretData] = await client.getSecret({ name: secret.name });
+              const folder = secretData.labels?.folder;
+              const env = secretData.labels?.environment || "(default)";
 
-          // 環境フィルタ
-          if (filterEnv && secretData.labels?.environment !== filterEnv) continue;
+              // 環境フィルタ
+              if (filterEnv && secretData.labels?.environment !== filterEnv) return null;
 
-          // 値を取得してキーワード検索
-          try {
-            const [version] = await client.accessSecretVersion({
-              name: `${secret.name}/versions/latest`,
-            });
-            const value = version.payload.data.toString("utf-8");
-            if (value.includes(keyword)) {
-              const { key } = getKeyFromSecret(secret.name.split("/").pop(), folder);
-              matches.push({ folder, env, key });
-              folders.add(folder);
+              // 値を取得してキーワード検索
+              const [version] = await client.accessSecretVersion({
+                name: `${secret.name}/versions/latest`,
+              });
+              const value = version.payload.data.toString("utf-8");
+              if (value.includes(keyword)) {
+                const { key } = getKeyFromSecret(secret.name.split("/").pop(), folder);
+                return { folder, env, key };
+              }
+            } catch {
+              // バージョンがない場合はスキップ
             }
-          } catch {
-            // バージョンがない場合はスキップ
-          }
-        }
+            return null;
+          })
+        );
+
+        const matches = results.filter((r) => r !== null);
+        const folders = new Set(matches.map((m) => m.folder));
 
         if (matches.length === 0) {
           console.log("No matches found");
@@ -461,6 +607,88 @@ async function runCli(args) {
         break;
       }
 
+      case "hook": {
+        const subcommand = parsed.positional[1];
+
+        if (subcommand === "install") {
+          const hooksDir = join(homedir(), '.git-hooks');
+          if (!existsSync(hooksDir)) mkdirSync(hooksDir, { recursive: true });
+
+          const hookTypes = [
+            'applypatch-msg', 'pre-applypatch', 'post-applypatch',
+            'pre-commit', 'prepare-commit-msg', 'commit-msg', 'post-commit',
+            'pre-rebase', 'post-checkout', 'post-merge',
+            'pre-push', 'pre-auto-gc', 'post-rewrite'
+          ];
+
+          for (const hookType of hookTypes) {
+            const hookPath = join(hooksDir, hookType);
+            let extraLogic = '';
+
+            if (hookType === 'pre-commit') {
+              extraLogic = `
+# gcloud-secrets: auto-sync .env to Secret Manager
+if command -v gcloud-secrets >/dev/null 2>&1; then
+  gcloud-secrets pre-commit
+fi
+`;
+            }
+
+            const hookScript = `#!/bin/sh
+# Global git hook: ${hookType}
+# Installed by gcloud-secrets
+${extraLogic}
+# Forward to .husky/${hookType} if it exists
+if [ -f "$(pwd)/.husky/${hookType}" ]; then
+  "$(pwd)/.husky/${hookType}" "$@"
+  exit_code=$?
+  if [ $exit_code -ne 0 ]; then
+    exit $exit_code
+  fi
+fi
+
+# Forward to .git/hooks/${hookType} if it exists
+GIT_DIR_HOOKS="$(git rev-parse --git-dir 2>/dev/null)/hooks/${hookType}"
+if [ -f "$GIT_DIR_HOOKS" ] && [ -x "$GIT_DIR_HOOKS" ]; then
+  "$GIT_DIR_HOOKS" "$@"
+  exit $?
+fi
+
+exit 0
+`;
+            writeFileSync(hookPath, hookScript);
+            chmodSync(hookPath, '755');
+          }
+
+          execSync('git config --global core.hooksPath ~/.git-hooks');
+          console.log(`グローバル git hooks をインストールしました:
+  フックディレクトリ: ${hooksDir}
+  対象: pre-commit (gcloud-secrets auto-sync)
+  互換性: .husky/ と .git/hooks/ にフォワード
+
+全リポジトリの git commit で .env が自動同期されます。`);
+
+        } else if (subcommand === "uninstall") {
+          try { execSync('git config --global --unset core.hooksPath', { stdio: 'ignore' }); } catch { }
+          const hooksDir = join(homedir(), '.git-hooks');
+          if (existsSync(hooksDir)) {
+            try {
+              rmSync(hooksDir, { recursive: true, force: true });
+            } catch (error) {
+              console.log(`⚠ ${hooksDir} の削除に失敗: ${error.message}`);
+              console.log(`手動で削除してください: rm -rf ${hooksDir}`);
+            }
+          }
+          console.log(`グローバル git hooks をアンインストールしました。`);
+
+        } else {
+          console.log(`使い方:
+  gcloud-secrets hook install      グローバル pre-commit hook をインストール
+  gcloud-secrets hook uninstall    グローバル pre-commit hook をアンインストール`);
+        }
+        break;
+      }
+
       default:
         console.log(`gcloud-secrets - GCP Secret Manager CLI
 
@@ -471,6 +699,9 @@ async function runCli(args) {
   gcloud-secrets push [folder] [file] [--env <env>]   シークレットをアップロード
   gcloud-secrets scan [basePath] [--env <env>]        Git リポジトリの .env 同期状況をスキャン
   gcloud-secrets search <keyword> [--env <env>]       値から逆引き検索
+  gcloud-secrets pre-commit                           .env 自動同期 (git hook 用)
+  gcloud-secrets hook install                         グローバル git hook インストール
+  gcloud-secrets hook uninstall                       グローバル git hook アンインストール
 
 オプション:
   --env, -e <env>  環境を指定 (dev, staging, prod など)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yhonda/gcloud-secrets",
-  "version": "2.0.10",
+  "version": "2.0.12",
   "description": "GCP Secret Manager を GitHub clone 風に管理する CLI ツール",
   "type": "module",
   "main": "cli.js",

package/skills/secrets.md

@@ -92,6 +92,25 @@ Found 3 matches in 2 folders
   未登録: 1
 ```
 
+### .env 自動同期 (pre-commit)
+```bash
+# カレントディレクトリの .env を Secret Manager に自動同期
+gcloud-secrets pre-commit
+```
+git hook 用の高速コマンド。キャッシュで .env の変更を検知し、変更がなければ API コール 0 で即座に終了。
+変更があれば `listSecrets` のフィルタ + 並列取得で高速にチェックし、新規/差分のある secret を自動 push。
+
+### グローバル git hook (hook)
+```bash
+# グローバル pre-commit hook をインストール
+gcloud-secrets hook install
+
+# アンインストール
+gcloud-secrets hook uninstall
+```
+`hook install` で全リポジトリの `git commit` 時に `pre-commit` が自動実行されます。
+既存の `.husky/` や `.git/hooks/` のフックにもフォワードするので互換性があります。
+
 ## 環境 (Environment) オプション
 
 `--env` または `-e` で環境を指定できます:
@@ -122,4 +141,10 @@ gcloud-secrets scan ~/ --env dev
 
 # 6. 特定の値がどこで使われているか検索
 gcloud-secrets search "line-client-id-xxx"
+
+# 7. グローバル git hook をインストール (全リポジトリで自動同期)
+gcloud-secrets hook install
+
+# 8. 手動で pre-commit を実行
+gcloud-secrets pre-commit
 ```