safe-push 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safe-push",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Git push safety checker - blocks pushes to forbidden areas",
   "type": "module",
   "bin": {
@@ -9,9 +9,16 @@
   "scripts": {
     "build": "bun build ./src/index.ts --outdir ./dist --target bun",
     "typecheck": "tsc --noEmit",
-    "dev": "bun run ./src/index.ts"
+    "dev": "bun run ./src/index.ts",
+    "generate-schema": "bun run ./scripts/generate-schema.ts"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.212.0",
+    "@opentelemetry/resources": "^2.5.1",
+    "@opentelemetry/sdk-trace-base": "^2.5.1",
+    "@opentelemetry/semantic-conventions": "^1.39.0",
     "commander": "^12.1.0",
     "jsonc-parser": "^3.3.1",
     "zod": "^3.23.8"
@@ -19,6 +26,7 @@
   "devDependencies": {
     "@types/bun": "latest",
     "@types/node": "^22.10.0",
-    "typescript": "^5.7.2"
+    "typescript": "^5.7.2",
+    "zod-to-json-schema": "^3.25.1"
   }
 }

package/scripts/generate-schema.ts

@@ -0,0 +1,13 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { ConfigSchema } from "../src/types";
+
+const jsonSchema = zodToJsonSchema(ConfigSchema, {
+  name: "SafePushConfig",
+  $refStrategy: "none",
+});
+
+const outPath = path.join(import.meta.dirname, "..", "config.schema.json");
+fs.writeFileSync(outPath, JSON.stringify(jsonSchema, null, 2) + "\n", "utf-8");
+console.log(`Generated ${outPath}`);

package/src/checker.ts

@@ -7,6 +7,7 @@ import {
   getDiffFiles,
   getRepoVisibility,
 } from "./git";
+import { withSpan } from "./telemetry";
 
 /**
  * Visibility チェック結果
@@ -24,20 +25,27 @@ export interface VisibilityCheckResult {
 export async function checkVisibility(
   allowedVisibility?: RepoVisibility[]
 ): Promise<VisibilityCheckResult | null> {
-  if (!allowedVisibility || allowedVisibility.length === 0) {
-    return null;
-  }
+  return withSpan("safe-push.check.visibility", async (span) => {
+    if (!allowedVisibility || allowedVisibility.length === 0) {
+      return null;
+    }
+
+    const visibility = await getRepoVisibility();
+    const allowed = allowedVisibility.includes(visibility as RepoVisibility);
 
-  const visibility = await getRepoVisibility();
-  const allowed = allowedVisibility.includes(visibility as RepoVisibility);
+    span.addEvent("visibility.result", {
+      value: visibility,
+      allowed,
+    });
 
-  return {
-    allowed,
-    reason: allowed
-      ? `Repository visibility "${visibility}" is allowed`
-      : `Repository visibility "${visibility}" is not in allowed list: [${allowedVisibility.join(", ")}]`,
-    visibility,
-  };
+    return {
+      allowed,
+      reason: allowed
+        ? `Repository visibility "${visibility}" is allowed`
+        : `Repository visibility "${visibility}" is not in allowed list: [${allowedVisibility.join(", ")}]`,
+      visibility,
+    };
+  });
 }
 
 /**
@@ -88,58 +96,69 @@ function findForbiddenFiles(
  * (禁止エリア変更なし) AND (新規ブランチ OR 最終コミットが自分)
  */
 export async function checkPush(config: Config): Promise<CheckResult> {
-  const currentBranch = await getCurrentBranch();
-  const newBranch = await isNewBranch();
-  const authorEmail = await getLastCommitAuthorEmail();
-  const localEmail = await getLocalEmail();
-  const diffFiles = await getDiffFiles();
+  return withSpan("safe-push.check.push", async (span) => {
+    const currentBranch = await getCurrentBranch();
+    const newBranch = await isNewBranch();
+    const authorEmail = await getLastCommitAuthorEmail();
+    const localEmail = await getLocalEmail();
+    const diffFiles = await getDiffFiles();
 
-  const forbiddenFiles = findForbiddenFiles(diffFiles, config.forbiddenPaths);
-  const hasForbiddenChanges = forbiddenFiles.length > 0;
-  const isOwnLastCommit =
-    authorEmail.toLowerCase() === localEmail.toLowerCase();
+    const forbiddenFiles = findForbiddenFiles(diffFiles, config.forbiddenPaths);
+    const hasForbiddenChanges = forbiddenFiles.length > 0;
+    const isOwnLastCommit =
+      authorEmail.toLowerCase() === localEmail.toLowerCase();
 
-  const details = {
-    isNewBranch: newBranch,
-    isOwnLastCommit,
-    hasForbiddenChanges,
-    forbiddenFiles,
-    currentBranch,
-    authorEmail,
-    localEmail,
-  };
-
-  // 禁止エリアに変更がある場合は常にブロック
-  if (hasForbiddenChanges) {
-    return {
-      allowed: false,
-      reason: `Forbidden files detected: ${forbiddenFiles.join(", ")}`,
-      details,
+    const details = {
+      isNewBranch: newBranch,
+      isOwnLastCommit,
+      hasForbiddenChanges,
+      forbiddenFiles,
+      currentBranch,
+      authorEmail,
+      localEmail,
     };
-  }
 
-  // 新規ブランチの場合は許可
-  if (newBranch) {
-    return {
-      allowed: true,
-      reason: "New branch - no restrictions",
-      details,
-    };
-  }
+    let result: CheckResult;
 
-  // 最終コミットが自分の場合は許可
-  if (isOwnLastCommit) {
-    return {
-      allowed: true,
-      reason: "Last commit is yours",
-      details,
-    };
-  }
+    // 禁止エリアに変更がある場合は常にブロック
+    if (hasForbiddenChanges) {
+      result = {
+        allowed: false,
+        reason: `Forbidden files detected: ${forbiddenFiles.join(", ")}`,
+        details,
+      };
+    } else if (newBranch) {
+      // 新規ブランチの場合は許可
+      result = {
+        allowed: true,
+        reason: "New branch - no restrictions",
+        details,
+      };
+    } else if (isOwnLastCommit) {
+      // 最終コミットが自分の場合は許可
+      result = {
+        allowed: true,
+        reason: "Last commit is yours",
+        details,
+      };
+    } else {
+      // それ以外はブロック
+      result = {
+        allowed: false,
+        reason: `Last commit is by someone else (${authorEmail})`,
+        details,
+      };
+    }
+
+    span.addEvent("check.result", {
+      allowed: result.allowed,
+      reason: result.reason,
+      isNewBranch: newBranch,
+      isOwnLastCommit,
+      hasForbiddenChanges,
+      forbiddenFileCount: forbiddenFiles.length,
+    });
 
-  // それ以外はブロック
-  return {
-    allowed: false,
-    reason: `Last commit is by someone else (${authorEmail})`,
-    details,
-  };
+    return result;
+  });
 }

package/src/commands/check.ts

@@ -3,6 +3,8 @@ import { loadConfig } from "../config";
 import { checkPush, checkVisibility } from "../checker";
 import { isGitRepository, hasCommits } from "../git";
 import { printError, printCheckResultJson, printCheckResultHuman } from "./utils";
+import { ExitError } from "../types";
+import { withSpan } from "../telemetry";
 
 /**
  * checkコマンドを作成
@@ -12,20 +14,27 @@ export function createCheckCommand(): Command {
     .description("Check if push is allowed")
     .option("--json", "Output result as JSON")
     .action(async (options: { json?: boolean }) => {
-      try {
+      await withSpan("safe-push.check", async (rootSpan) => {
         // Gitリポジトリ内か確認
         if (!(await isGitRepository())) {
           printError("Not a git repository");
-          process.exit(1);
+          throw new ExitError(1);
         }
 
         // コミットが存在するか確認
         if (!(await hasCommits())) {
           printError("No commits found");
-          process.exit(1);
+          throw new ExitError(1);
         }
 
         const config = loadConfig();
+
+        rootSpan.addEvent("config.loaded", {
+          forbiddenPaths: JSON.stringify(config.forbiddenPaths),
+          onForbidden: config.onForbidden,
+          hasVisibilityRule: !!(config.allowedVisibility && config.allowedVisibility.length > 0),
+        });
+
         const result = await checkPush(config);
 
         // visibility チェック
@@ -41,6 +50,7 @@ export function createCheckCommand(): Command {
               }
             }
           } catch (error) {
+            if (error instanceof ExitError) throw error;
             result.details.repoVisibility = "unknown";
             result.details.visibilityAllowed = false;
             result.allowed = false;
@@ -54,12 +64,9 @@ export function createCheckCommand(): Command {
           printCheckResultHuman(result);
         }
 
-        process.exit(result.allowed ? 0 : 1);
-      } catch (error) {
-        printError(
-          `Check failed: ${error instanceof Error ? error.message : String(error)}`
-        );
-        process.exit(1);
-      }
+        if (!result.allowed) {
+          throw new ExitError(1);
+        }
+      });
     });
 }

package/src/commands/mcp.ts

@@ -0,0 +1,383 @@
+import { Command } from "commander";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import {
+  createServer,
+  type IncomingMessage,
+  type ServerResponse,
+} from "node:http";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import * as path from "node:path";
+import { loadConfig } from "../config";
+import { checkPush, checkVisibility } from "../checker";
+import { isGitRepository, hasCommits, execPush } from "../git";
+
+function createMcpServer(): McpServer {
+  const server = new McpServer({
+    name: "safe-push",
+    version: "0.3.0",
+  });
+
+  server.tool(
+    "push",
+    "Run safety checks and execute git push. Checks forbidden paths, branch ownership, and repository visibility before pushing.",
+    {
+      force: z
+        .boolean()
+        .optional()
+        .describe(
+          "Bypass safety checks (except visibility). Use when a previous push was blocked and you want to override."
+        ),
+      dryRun: z
+        .boolean()
+        .optional()
+        .describe("Show what would be pushed without actually pushing."),
+      args: z
+        .array(z.string())
+        .optional()
+        .describe(
+          "Additional git push arguments (e.g. remote name, refspec, flags like --no-verify)."
+        ),
+    },
+    async ({ force, dryRun, args }) => {
+      try {
+        // SAFE_PUSH_GIT_ROOT が設定されている場合は chdir
+        const gitRoot = process.env.SAFE_PUSH_GIT_ROOT;
+        if (gitRoot) {
+          process.chdir(path.resolve(gitRoot));
+        }
+
+        // Git リポジトリ内か確認
+        if (!(await isGitRepository())) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: "Error: Not a git repository",
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        // コミットが存在するか確認
+        if (!(await hasCommits())) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: "Error: No commits found",
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        const config = loadConfig();
+        const gitArgs = args ?? [];
+
+        // visibility チェック（force でもバイパス不可）
+        if (config.allowedVisibility && config.allowedVisibility.length > 0) {
+          try {
+            const visibilityResult = await checkVisibility(
+              config.allowedVisibility
+            );
+            if (visibilityResult && !visibilityResult.allowed) {
+              return {
+                content: [
+                  {
+                    type: "text" as const,
+                    text: `Blocked: ${visibilityResult.reason}`,
+                  },
+                ],
+                isError: true,
+              };
+            }
+          } catch (error) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: `Failed to check repository visibility. Ensure 'gh' CLI is installed and authenticated.\n${error instanceof Error ? error.message : String(error)}`,
+                },
+              ],
+              isError: true,
+            };
+          }
+        }
+
+        // force の場合はチェックをスキップ
+        if (force) {
+          if (dryRun) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: "Dry run: would push (checks bypassed with force)",
+                },
+              ],
+            };
+          }
+
+          const result = await execPush(gitArgs);
+          if (result.success) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: result.output
+                    ? `Push successful (force)\n${result.output}`
+                    : "Push successful (force)",
+                },
+              ],
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Push failed: ${result.output}`,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        // 通常のチェック
+        const checkResult = await checkPush(config);
+
+        if (!checkResult.allowed) {
+          const details = checkResult.details;
+          let message = `Push blocked: ${checkResult.reason}\n\nDetails:\n- Branch: ${details.currentBranch}\n- New branch: ${details.isNewBranch}\n- Own last commit: ${details.isOwnLastCommit}\n- Author: ${details.authorEmail}\n- Local: ${details.localEmail}`;
+
+          if (details.forbiddenFiles.length > 0) {
+            message += `\n- Forbidden files: ${details.forbiddenFiles.join(", ")}`;
+          }
+
+          // onForbidden: "prompt" の場合、MCP ではインタラクティブ確認不可なので force を案内
+          if (
+            config.onForbidden === "prompt" &&
+            details.hasForbiddenChanges
+          ) {
+            message +=
+              '\n\nThis repository is configured with onForbidden: "prompt". Since interactive confirmation is not available via MCP, you can re-run with force: true to bypass this check.';
+          }
+
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: message,
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        // チェック通過
+        if (dryRun) {
+          const details = checkResult.details;
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: `Dry run: would push\nReason: ${checkResult.reason}\nBranch: ${details.currentBranch}`,
+              },
+            ],
+          };
+        }
+
+        // push 実行
+        const result = await execPush(gitArgs);
+        if (result.success) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: result.output
+                  ? `Push successful\n${result.output}`
+                  : "Push successful",
+              },
+            ],
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Push failed: ${result.output}`,
+            },
+          ],
+          isError: true,
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Unexpected error: ${error instanceof Error ? error.message : String(error)}`,
+            },
+          ],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  return server;
+}
+
+async function startStdioServer(): Promise<void> {
+  const server = createMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("safe-push MCP server started (stdio)");
+  await new Promise<void>((resolve) => {
+    transport.onclose = () => resolve();
+  });
+}
+
+async function startHttpServer(port: number): Promise<void> {
+  const transports = new Map<string, StreamableHTTPServerTransport>();
+
+  function readBody(req: IncomingMessage): Promise<string> {
+    return new Promise((resolve, reject) => {
+      let data = "";
+      req.on("data", (chunk: Buffer) => {
+        data += chunk.toString();
+      });
+      req.on("end", () => resolve(data));
+      req.on("error", reject);
+    });
+  }
+
+  const httpServer = createServer(
+    async (req: IncomingMessage, res: ServerResponse) => {
+      const url = new URL(
+        req.url ?? "/",
+        `http://${req.headers.host ?? "localhost"}`
+      );
+
+      if (url.pathname !== "/mcp") {
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not Found" }));
+        return;
+      }
+
+      const method = req.method?.toUpperCase();
+
+      if (method === "POST") {
+        try {
+          const body = await readBody(req);
+          const parsedBody = JSON.parse(body);
+          const sessionId = req.headers["mcp-session-id"] as
+            | string
+            | undefined;
+
+          let transport: StreamableHTTPServerTransport;
+
+          if (sessionId && transports.has(sessionId)) {
+            transport = transports.get(sessionId)!;
+          } else if (!sessionId && isInitializeRequest(parsedBody)) {
+            transport = new StreamableHTTPServerTransport({
+              sessionIdGenerator: () => randomUUID(),
+              onsessioninitialized: (sid: string) => {
+                transports.set(sid, transport);
+                console.error(`Session initialized: ${sid}`);
+              },
+            });
+
+            transport.onclose = () => {
+              const sid = transport.sessionId;
+              if (sid) {
+                transports.delete(sid);
+                console.error(`Session closed: ${sid}`);
+              }
+            };
+
+            const server = createMcpServer();
+            await server.connect(transport);
+            await transport.handleRequest(req, res, parsedBody);
+            return;
+          } else {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: {
+                  code: -32000,
+                  message: "Bad Request: No valid session ID provided",
+                },
+                id: null,
+              })
+            );
+            return;
+          }
+
+          await transport.handleRequest(req, res, parsedBody);
+        } catch {
+          if (!res.headersSent) {
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                jsonrpc: "2.0",
+                error: { code: -32603, message: "Internal server error" },
+                id: null,
+              })
+            );
+          }
+        }
+      } else if (method === "GET") {
+        const sessionId = req.headers["mcp-session-id"] as string | undefined;
+        if (!sessionId || !transports.has(sessionId)) {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Invalid or missing session ID");
+          return;
+        }
+        const transport = transports.get(sessionId)!;
+        await transport.handleRequest(req, res);
+      } else if (method === "DELETE") {
+        const sessionId = req.headers["mcp-session-id"] as string | undefined;
+        if (!sessionId || !transports.has(sessionId)) {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Invalid or missing session ID");
+          return;
+        }
+        const transport = transports.get(sessionId)!;
+        await transport.handleRequest(req, res);
+      } else {
+        res.writeHead(405, { "Content-Type": "text/plain" });
+        res.end("Method Not Allowed");
+      }
+    }
+  );
+
+  await new Promise<void>((resolve) => {
+    httpServer.listen(port, () => {
+      console.error(`safe-push MCP server started (HTTP) on port ${port}`);
+    });
+    httpServer.on("close", resolve);
+  });
+}
+
+export function createMcpCommand(): Command {
+  const cmd = new Command("mcp")
+    .description("Start MCP server for Claude Code integration")
+    .option("--http", "Start as HTTP server instead of stdio")
+    .option("--port <number>", "HTTP server port (default: PORT env or 3000)")
+    .action(async (opts: { http?: boolean; port?: string }) => {
+      if (opts.http) {
+        const port = opts.port
+          ? Number(opts.port)
+          : Number(process.env.PORT) || 3000;
+        await startHttpServer(port);
+      } else {
+        await startStdioServer();
+      }
+    });
+
+  return cmd;
+}