@hayasaka7/go-arch-xray 0.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 HAYASAKA7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,53 @@
+# go-arch-xray
+
+npm distribution of [`go-arch-xray`](https://github.com/HAYASAKA7/go-arch-xray) — a
+Model Context Protocol (MCP) server for static analysis of Go codebases.
+
+This package contains a small Node launcher. On install, a `postinstall` script
+downloads the matching native binary (Windows / macOS / Linux × x64 / arm64)
+from the corresponding [GitHub Release](https://github.com/HAYASAKA7/go-arch-xray/releases).
+
+## Install
+
+```bash
+npm install -g @hayasaka7/go-arch-xray
+```
+
+Or use it without installing:
+
+```bash
+npx -y @hayasaka7/go-arch-xray
+```
+
+## MCP host configuration
+
+```json
+{
+  "mcpServers": {
+    "go-arch-xray": {
+      "command": "npx",
+      "args": ["-y", "@hayasaka7/go-arch-xray"]
+    }
+  }
+}
+```
+
+## Environment variables
+
+- `GO_ARCH_XRAY_BIN` — absolute path to a pre-installed binary. When set,
+  `postinstall` is skipped and the launcher invokes that binary directly.
+  Useful for air-gapped environments or corporate package mirrors.
+
+## Troubleshooting
+
+- **Install ran with `--ignore-scripts`**: download blocked. Run
+  `npm rebuild @hayasaka7/go-arch-xray` once, or set `GO_ARCH_XRAY_BIN`.
+- **Behind a firewall**: download the matching release asset manually from
+  <https://github.com/HAYASAKA7/go-arch-xray/releases>, extract it, and set
+  `GO_ARCH_XRAY_BIN` to the binary path.
+- **Unsupported platform**: build from source —
+  see <https://github.com/HAYASAKA7/go-arch-xray#build-from-source>.
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/bin/go-arch-xray.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// Thin launcher: locates the platform-specific go-arch-xray binary downloaded
+// by install.js (or pointed to by GO_ARCH_XRAY_BIN) and execs it with the
+// caller's argv, inheriting stdio and exit code.
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const REPO = "HAYASAKA7/go-arch-xray";
+
+function resolveBinary() {
+  if (process.env.GO_ARCH_XRAY_BIN) {
+    return process.env.GO_ARCH_XRAY_BIN;
+  }
+  const ext = process.platform === "win32" ? ".exe" : "";
+  return path.join(__dirname, `go-arch-xray${ext}`);
+}
+
+const binPath = resolveBinary();
+
+if (!fs.existsSync(binPath)) {
+  process.stderr.write(
+    `[go-arch-xray] binary not found at ${binPath}\n` +
+      `The npm postinstall step did not run or failed.\n` +
+      `Try one of:\n` +
+      `  npm rebuild @hayasaka7/go-arch-xray\n` +
+      `  download the asset manually from https://github.com/${REPO}/releases and set GO_ARCH_XRAY_BIN\n`
+  );
+  process.exit(1);
+}
+
+const result = spawnSync(binPath, process.argv.slice(2), { stdio: "inherit" });
+
+if (result.error) {
+  process.stderr.write(`[go-arch-xray] failed to spawn binary: ${result.error.message}\n`);
+  process.exit(1);
+}
+
+if (result.signal) {
+  process.kill(process.pid, result.signal);
+}
+
+process.exit(result.status ?? 1);

package/install.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+// Downloads the platform-specific go-arch-xray binary from the matching
+// GitHub Release and extracts it into ./bin. Runs automatically as the
+// npm `postinstall` step.
+//
+// Override the binary location entirely by setting GO_ARCH_XRAY_BIN to an
+// absolute path; in that case this script does nothing.
+//
+// Skip the download in CI / offline installs with `npm install --ignore-scripts`.
+// The bin shim will print a clear remediation message at first run.
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { spawnSync } = require("child_process");
+const { pipeline } = require("stream/promises");
+const { Readable } = require("stream");
+
+const REPO = "HAYASAKA7/go-arch-xray";
+const pkg = require("./package.json");
+const VERSION = pkg.version;
+const TAG = `v${VERSION}`;
+
+const PLATFORM_MAP = {
+  "win32-x64": { goos: "windows", goarch: "amd64", ext: ".exe", archive: "zip" },
+  "win32-arm64": { goos: "windows", goarch: "arm64", ext: ".exe", archive: "zip" },
+  "darwin-x64": { goos: "darwin", goarch: "amd64", ext: "", archive: "tar.gz" },
+  "darwin-arm64": { goos: "darwin", goarch: "arm64", ext: "", archive: "tar.gz" },
+  "linux-x64": { goos: "linux", goarch: "amd64", ext: "", archive: "tar.gz" },
+  "linux-arm64": { goos: "linux", goarch: "arm64", ext: "", archive: "tar.gz" },
+};
+
+function log(msg) {
+  process.stderr.write(`[go-arch-xray] ${msg}\n`);
+}
+
+function fail(msg, code = 1) {
+  log(`ERROR: ${msg}`);
+  process.exit(code);
+}
+
+function detectTarget() {
+  const key = `${process.platform}-${process.arch}`;
+  const target = PLATFORM_MAP[key];
+  if (!target) {
+    fail(
+      `Unsupported platform ${key}. Supported: ${Object.keys(PLATFORM_MAP).join(", ")}.\n` +
+        `Build from source: https://github.com/${REPO}#build-from-source`
+    );
+  }
+  return { key, ...target };
+}
+
+function binaryPath(target) {
+  const binDir = path.join(__dirname, "bin");
+  const name = `go-arch-xray${target.ext}`;
+  return { binDir, binPath: path.join(binDir, name) };
+}
+
+function archiveInternalName(target) {
+  return `go-arch-xray-${target.goos}-${target.goarch}${target.ext}`;
+}
+
+function archiveAssetName(target) {
+  return `go-arch-xray-${TAG}-${target.goos}-${target.goarch}.${target.archive}`;
+}
+
+function assetUrl(target) {
+  return `https://github.com/${REPO}/releases/download/${TAG}/${archiveAssetName(target)}`;
+}
+
+async function download(url, destFile) {
+  log(`downloading ${url}`);
+  const res = await fetch(url, { redirect: "follow" });
+  if (!res.ok) {
+    throw new Error(`HTTP ${res.status} ${res.statusText} for ${url}`);
+  }
+  await pipeline(Readable.fromWeb(res.body), fs.createWriteStream(destFile));
+}
+
+function ensureTar() {
+  const probe = spawnSync("tar", ["--version"], { stdio: "ignore" });
+  if (probe.status !== 0) {
+    fail(
+      "`tar` was not found on PATH. Install GNU tar / bsdtar, or set " +
+        "GO_ARCH_XRAY_BIN to an existing binary path."
+    );
+  }
+}
+
+function extract(archivePath, destDir) {
+  ensureTar();
+  // Modern bsdtar (Windows 10 1803+, macOS, Linux) handles both .tar.gz and .zip via -xf.
+  const result = spawnSync("tar", ["-xf", archivePath, "-C", destDir], {
+    stdio: "inherit",
+  });
+  if (result.status !== 0) {
+    fail(`tar extraction failed (exit ${result.status})`);
+  }
+}
+
+async function main() {
+  if (process.env.GO_ARCH_XRAY_BIN) {
+    log(`GO_ARCH_XRAY_BIN is set; skipping download.`);
+    return;
+  }
+
+  const target = detectTarget();
+  const { binDir, binPath } = binaryPath(target);
+
+  if (fs.existsSync(binPath)) {
+    log(`binary already present at ${binPath}; skipping download.`);
+    return;
+  }
+
+  fs.mkdirSync(binDir, { recursive: true });
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "go-arch-xray-"));
+  const archivePath = path.join(tmpDir, archiveAssetName(target));
+
+  try {
+    await download(assetUrl(target), archivePath);
+    extract(archivePath, tmpDir);
+
+    const extractedName = archiveInternalName(target);
+    const extractedPath = path.join(tmpDir, extractedName);
+    if (!fs.existsSync(extractedPath)) {
+      fail(
+        `expected '${extractedName}' inside archive but it was not found. ` +
+          `Open an issue: https://github.com/${REPO}/issues`
+      );
+    }
+
+    fs.renameSync(extractedPath, binPath);
+    if (process.platform !== "win32") {
+      fs.chmodSync(binPath, 0o755);
+    }
+    log(`installed ${binPath}`);
+  } catch (err) {
+    fail(
+      `failed to install binary: ${err && err.message ? err.message : err}\n` +
+        `URL: ${assetUrl(target)}\n` +
+        `You can download the asset manually, extract it, and either drop the binary at\n` +
+        `  ${binPath}\n` +
+        `or set GO_ARCH_XRAY_BIN to its absolute path.`
+    );
+  } finally {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      /* best effort */
+    }
+  }
+}
+
+main().catch((err) => fail(err && err.stack ? err.stack : String(err)));

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@hayasaka7/go-arch-xray",
+  "version": "0.5.0",
+  "description": "Model Context Protocol server for static analysis of Go codebases (call graphs, import graphs, interface topology, struct lifecycle, HTTP routes).",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "golang",
+    "go",
+    "static-analysis",
+    "call-graph",
+    "ssa",
+    "architecture"
+  ],
+  "homepage": "https://github.com/HAYASAKA7/go-arch-xray#readme",
+  "bugs": {
+    "url": "https://github.com/HAYASAKA7/go-arch-xray/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HAYASAKA7/go-arch-xray.git"
+  },
+  "license": "MIT",
+  "author": "HAYASAKA7",
+  "bin": {
+    "go-arch-xray": "bin/go-arch-xray.js"
+  },
+  "files": [
+    "install.js",
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}