@qinghuangniao/heron-connect 1.0.0

package/README.md

@@ -0,0 +1,42 @@
+# heron-connect
+
+A bridge service that connects local AI coding agents to messaging platforms, so you can talk to your AI coding assistant directly from Feishu, Telegram, Discord, Slack, and more.
+
+## Install
+
+```bash
+npm install -g @qinghuangniao/heron-connect
+```
+
+## Usage
+
+```bash
+# Check version
+heron-connect --version
+
+# Create config
+heron-connect
+
+# Edit config.toml, then run
+heron-connect --config /path/to/config.toml
+```
+
+## Documentation
+
+Repository: https://github.com/janostudio/heron-connect
+
+Full documentation: see the repository README and `docs/` directory.
+
+## Publish Flow
+
+Running `npm publish` in this directory triggers `prepublishOnly`, which:
+
+1. builds missing release archives into `../dist`
+2. uses `gh` to create or update the GitHub release `v<package-version>`
+3. uploads required archives and `checksums.txt` before publishing to npm
+
+Prerequisites:
+
+- `gh auth login`
+- Go build environment available locally
+- release repository push permission on `janostudio/heron-connect`

package/install.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const http = require("http");
+const zlib = require("zlib");
+
+const PACKAGE = require("./package.json");
+const VERSION = `v${PACKAGE.version}`;
+const NAME = "heron-connect";
+
+const GITHUB_REPO = "janostudio/heron-connect";
+
+const PLATFORM_MAP = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+};
+
+const ARCH_MAP = {
+  x64: "amd64",
+  arm64: "arm64",
+};
+
+function getPlatformInfo() {
+  const platform = PLATFORM_MAP[process.platform];
+  const arch = ARCH_MAP[process.arch];
+  if (!platform || !arch) {
+    throw new Error(
+      `Unsupported platform: ${process.platform}/${process.arch}. ` +
+        `Supported: linux/darwin/windows x64/arm64`
+    );
+  }
+  const ext = platform === "windows" ? ".zip" : ".tar.gz";
+  const filename = `${NAME}-${VERSION}-${platform}-${arch}${ext}`;
+  return { platform, arch, ext, filename };
+}
+
+function getDownloadURLs(filename) {
+  return [
+    `https://github.com/${GITHUB_REPO}/releases/download/${VERSION}/${filename}`,
+  ];
+}
+
+function fetch(url, redirects = 5) {
+  return new Promise((resolve, reject) => {
+    if (redirects <= 0) return reject(new Error("Too many redirects"));
+    const mod = url.startsWith("https") ? https : http;
+    mod
+      .get(url, { headers: { "User-Agent": "heron-connect-npm" } }, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          return resolve(fetch(res.headers.location, redirects - 1));
+        }
+        if (res.statusCode !== 200) {
+          res.resume();
+          return reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+        }
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => resolve(Buffer.concat(chunks)));
+        res.on("error", reject);
+      })
+      .on("error", reject);
+  });
+}
+
+async function download(urls) {
+  for (const url of urls) {
+    try {
+      console.log(`[heron-connect] Downloading from ${url}`);
+      const data = await fetch(url);
+      console.log(`[heron-connect] Downloaded ${(data.length / 1024 / 1024).toFixed(1)} MB`);
+      return data;
+    } catch (err) {
+      console.warn(`[heron-connect] Failed: ${err.message}, trying next source...`);
+    }
+  }
+  throw new Error(
+    `[heron-connect] Could not download binary from any source.\n` +
+      `  Tried: ${urls.join(", ")}\n` +
+      `  You can download manually from https://github.com/${GITHUB_REPO}/releases`
+  );
+}
+
+function extractTarGz(buffer, destDir, binaryName) {
+  const tmpFile = path.join(destDir, "_tmp.tar.gz");
+  fs.writeFileSync(tmpFile, buffer);
+  try {
+    execSync(`tar xzf "${tmpFile}" -C "${destDir}"`, { stdio: "pipe" });
+  } finally {
+    fs.unlinkSync(tmpFile);
+  }
+  const extracted = fs.readdirSync(destDir).find((f) => f.startsWith(NAME) && !f.endsWith(".tar.gz"));
+  if (extracted && extracted !== binaryName) {
+    fs.renameSync(path.join(destDir, extracted), path.join(destDir, binaryName));
+  }
+}
+
+function extractZip(buffer, destDir, binaryName) {
+  const tmpFile = path.join(destDir, "_tmp.zip");
+  fs.writeFileSync(tmpFile, buffer);
+  try {
+    try {
+      execSync(`unzip -o "${tmpFile}" -d "${destDir}"`, { stdio: "pipe" });
+    } catch {
+      execSync(`powershell -Command "Expand-Archive -Force '${tmpFile}' '${destDir}'"`, {
+        stdio: "pipe",
+      });
+    }
+  } finally {
+    try { fs.unlinkSync(tmpFile); } catch {}
+  }
+  const extracted = fs.readdirSync(destDir).find((f) => f.startsWith(NAME) && f.endsWith(".exe"));
+  if (extracted && extracted !== binaryName) {
+    fs.renameSync(path.join(destDir, extracted), path.join(destDir, binaryName));
+  }
+}
+
+// parseVersion splits "1.2.3-beta.1" into { nums: [1,2,3], preTag: "beta", preNum: 1 }
+function parseVersion(v) {
+  v = v.replace(/^v/, "").trim();
+  const [base, ...rest] = v.split("-");
+  const nums = base.split(".").map(Number);
+  const pre = rest.join("-");
+  const m = pre.match(/^([a-zA-Z]+)\.?(\d+)?$/);
+  return { nums, preTag: m ? m[1] : pre, preNum: m && m[2] ? parseInt(m[2], 10) : 0, hasPre: pre !== "" };
+}
+
+// isNewerOrEqual returns true if installed >= expected
+function isNewerOrEqual(installed, expected) {
+  const a = parseVersion(installed);
+  const b = parseVersion(expected);
+  const len = Math.max(a.nums.length, b.nums.length);
+  for (let i = 0; i < len; i++) {
+    const av = a.nums[i] || 0;
+    const bv = b.nums[i] || 0;
+    if (av > bv) return true;
+    if (av < bv) return false;
+  }
+  if (!a.hasPre && b.hasPre) return true;
+  if (a.hasPre && !b.hasPre) return false;
+  if (!a.hasPre && !b.hasPre) return true;
+  // Both pre-release: compare tag then number (rc > beta, beta.10 > beta.9)
+  if (a.preTag !== b.preTag) return a.preTag > b.preTag;
+  return a.preNum >= b.preNum;
+}
+
+async function main() {
+  const { platform, arch, ext, filename } = getPlatformInfo();
+  console.log(`[heron-connect] Platform: ${platform}/${arch}`);
+
+  const binDir = path.join(__dirname, "bin");
+  fs.mkdirSync(binDir, { recursive: true });
+
+  const binaryName = platform === "windows" ? `${NAME}.exe` : NAME;
+  const binaryPath = path.join(binDir, binaryName);
+
+  if (fs.existsSync(binaryPath)) {
+    try {
+      const out = execSync(`"${binaryPath}" --version`, { encoding: "utf8", timeout: 5000 });
+      const expectedVer = VERSION.slice(1); // remove leading "v"
+      if (out.includes(expectedVer)) {
+        console.log(`[heron-connect] Binary ${VERSION} already installed, skipping.`);
+        return;
+      }
+      // Don't downgrade: if existing binary is newer, keep it
+      const match = out.match(/(\d+\.\d+\.\d+[^\s]*)/);
+      if (match && isNewerOrEqual(match[1], expectedVer)) {
+        console.log(`[heron-connect] Binary ${match[1]} is newer than ${VERSION}, skipping.`);
+        return;
+      }
+      console.log(`[heron-connect] Existing binary is outdated, upgrading to ${VERSION}...`);
+      fs.unlinkSync(binaryPath);
+    } catch {
+      console.log(`[heron-connect] Replacing existing binary with ${VERSION}...`);
+      fs.unlinkSync(binaryPath);
+    }
+  }
+
+  const urls = getDownloadURLs(filename);
+  const data = await download(urls);
+
+  if (ext === ".tar.gz") {
+    extractTarGz(data, binDir, binaryName);
+  } else {
+    extractZip(data, binDir, binaryName);
+  }
+
+  if (platform !== "windows") {
+    fs.chmodSync(binaryPath, 0o755);
+  }
+
+  if (platform === "darwin") {
+    try {
+      execSync(`xattr -d com.apple.quarantine "${binaryPath}"`, { stdio: "pipe" });
+      console.log(`[heron-connect] Removed macOS quarantine attribute`);
+    } catch {
+      // xattr fails if the attribute doesn't exist, which is fine
+    }
+  }
+
+  console.log(`[heron-connect] Installed to ${binaryPath}`);
+}
+
+main().catch((err) => {
+  console.error(err.message);
+  console.error(
+    "[heron-connect] Installation failed. You can install manually:\n" +
+      `  https://github.com/${GITHUB_REPO}/releases/tag/${VERSION}`
+  );
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@qinghuangniao/heron-connect",
+  "version": "1.0.0",
+  "description": "Multi-IM agent bridge connecting AI coding agents to messaging platforms",
+  "keywords": [
+    "claude-code",
+    "ai-coding",
+    "feishu",
+    "dingtalk",
+    "slack",
+    "telegram",
+    "discord",
+    "line",
+    "wechat-work",
+    "chatbot",
+    "bridge",
+    "agent"
+  ],
+  "homepage": "https://github.com/janostudio/heron-connect",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/janostudio/heron-connect.git"
+  },
+  "license": "MIT",
+  "author": "janostudio",
+  "bin": {
+    "heron-connect": "run.js"
+  },
+  "scripts": {
+    "prepare-release": "node release-assets.js build",
+    "sync-release": "node release-assets.js ensure",
+    "prepublishOnly": "node release-assets.js ensure",
+    "postinstall": "node install.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "install.js",
+    "run.js",
+    "release-assets.js",
+    "README.md"
+  ]
+}

package/release-assets.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { execFileSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+
+const PACKAGE = require("./package.json");
+
+const REPO = "janostudio/heron-connect";
+const APP = "heron-connect";
+const VERSION = `v${PACKAGE.version}`;
+const ROOT_DIR = path.resolve(__dirname, "..");
+const DIST_DIR = path.join(ROOT_DIR, "dist");
+
+const PLATFORMS = [
+  ["linux", "amd64"],
+  ["linux", "arm64"],
+  ["darwin", "amd64"],
+  ["darwin", "arm64"],
+  ["windows", "amd64"],
+  ["windows", "arm64"],
+];
+
+function run(bin, args, opts = {}) {
+  return execFileSync(bin, args, {
+    cwd: ROOT_DIR,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf8",
+    ...opts,
+  }).trim();
+}
+
+function archiveName(goos, goarch) {
+  const base = `${APP}-${VERSION}-${goos}-${goarch}`;
+  return goos === "windows" ? `${base}.zip` : `${base}.tar.gz`;
+}
+
+function expectedArchives() {
+  return PLATFORMS.map(([goos, goarch]) => archiveName(goos, goarch));
+}
+
+function expectedDistFiles() {
+  return [...expectedArchives(), "checksums.txt"];
+}
+
+function missingFiles(dir, names) {
+  return names.filter((name) => !fs.existsSync(path.join(dir, name)));
+}
+
+function buildReleaseAssets() {
+  console.log(`[release-assets] Building release archives for ${VERSION}`);
+  execFileSync("make", ["release-all", `VERSION=${VERSION}`], {
+    cwd: ROOT_DIR,
+    stdio: "inherit",
+  });
+}
+
+function ensureLocalAssets() {
+  const missing = missingFiles(DIST_DIR, expectedDistFiles());
+  if (missing.length === 0) {
+    console.log(`[release-assets] Local release assets already exist in ${DIST_DIR}`);
+    return;
+  }
+
+  console.log(`[release-assets] Missing local release assets:`);
+  for (const name of missing) console.log(`  - ${name}`);
+  buildReleaseAssets();
+
+  const stillMissing = missingFiles(DIST_DIR, expectedDistFiles());
+  if (stillMissing.length > 0) {
+    throw new Error(
+      `Local release assets are still missing after build: ${stillMissing.join(", ")}`
+    );
+  }
+}
+
+function hasGh() {
+  try {
+    run("gh", ["--version"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function hasGhAuth() {
+  try {
+    execFileSync("gh", ["auth", "status"], {
+      cwd: ROOT_DIR,
+      stdio: "ignore",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function releaseInfo() {
+  try {
+    return JSON.parse(run("gh", ["release", "view", VERSION, "--repo", REPO, "--json", "tagName,assets"]));
+  } catch {
+    return null;
+  }
+}
+
+function ensureReleaseExists() {
+  if (releaseInfo()) {
+    console.log(`[release-assets] GitHub release ${VERSION} already exists`);
+    return;
+  }
+
+  console.log(`[release-assets] Creating GitHub release ${VERSION}`);
+  const notes = [
+    `Release assets for npm package ${PACKAGE.name}@${PACKAGE.version}.`,
+    "",
+    "This is an unofficial personal fork build.",
+  ].join("\n");
+
+  execFileSync(
+    "gh",
+    ["release", "create", VERSION, "--repo", REPO, "--title", VERSION, "--notes", notes],
+    { cwd: ROOT_DIR, stdio: "inherit" }
+  );
+}
+
+function uploadReleaseAssets() {
+  const files = expectedDistFiles().map((name) => path.join(DIST_DIR, name));
+  console.log(`[release-assets] Uploading release assets to ${REPO}@${VERSION}`);
+  execFileSync("gh", ["release", "upload", VERSION, "--repo", REPO, "--clobber", ...files], {
+    cwd: ROOT_DIR,
+    stdio: "inherit",
+  });
+}
+
+function ensureRemoteAssets() {
+  if (!hasGh()) {
+    throw new Error(
+      "GitHub CLI `gh` is not installed. Install it or manually upload dist/ archives before npm publish."
+    );
+  }
+  if (!hasGhAuth()) {
+    throw new Error(
+      "GitHub CLI is not authenticated. Run `gh auth login` before npm publish so release assets can be synced."
+    );
+  }
+
+  ensureReleaseExists();
+  uploadReleaseAssets();
+
+  const info = releaseInfo();
+  const assetNames = new Set((info && info.assets ? info.assets : []).map((asset) => asset.name));
+  const missingRemote = expectedDistFiles().filter((name) => !assetNames.has(name));
+  if (missingRemote.length > 0) {
+    throw new Error(`Remote release is missing assets after upload: ${missingRemote.join(", ")}`);
+  }
+
+  console.log(`[release-assets] GitHub release ${VERSION} is ready for npm publish`);
+}
+
+function printExpectedArchives() {
+  for (const name of expectedArchives()) {
+    console.log(name);
+  }
+}
+
+function main() {
+  const command = process.argv[2] || "ensure";
+
+  if (command === "list") {
+    printExpectedArchives();
+    return;
+  }
+
+  if (command === "build") {
+    ensureLocalAssets();
+    return;
+  }
+
+  if (command === "ensure") {
+    ensureLocalAssets();
+    ensureRemoteAssets();
+    return;
+  }
+
+  console.error("Usage: node release-assets.js [list|build|ensure]");
+  process.exit(1);
+}
+
+main();

package/run.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { execFileSync, execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+
+const PACKAGE = require("./package.json");
+const EXPECTED_VER = PACKAGE.version; // e.g. "1.1.0-beta.4"
+const NAME = "heron-connect";
+const binDir = path.join(__dirname, "bin");
+const ext = process.platform === "win32" ? ".exe" : "";
+const binaryPath = path.join(binDir, NAME + ext);
+
+// parseVersion splits "1.2.3-beta.1" into { nums: [1,2,3], preTag: "beta", preNum: 1 }
+function parseVersion(v) {
+  v = v.replace(/^v/, "").trim();
+  const [base, ...rest] = v.split("-");
+  const nums = base.split(".").map(Number);
+  const pre = rest.join("-");
+  const m = pre.match(/^([a-zA-Z]+)\.?(\d+)?$/);
+  return { nums, preTag: m ? m[1] : pre, preNum: m && m[2] ? parseInt(m[2], 10) : 0, hasPre: pre !== "" };
+}
+
+// isNewerOrEqual returns true if installed >= expected
+function isNewerOrEqual(installed, expected) {
+  const a = parseVersion(installed);
+  const b = parseVersion(expected);
+  const len = Math.max(a.nums.length, b.nums.length);
+  for (let i = 0; i < len; i++) {
+    const av = a.nums[i] || 0;
+    const bv = b.nums[i] || 0;
+    if (av > bv) return true;
+    if (av < bv) return false;
+  }
+  // Same base: no pre-release >= any pre-release (1.2.3 >= 1.2.3-beta.1)
+  if (!a.hasPre && b.hasPre) return true;
+  if (a.hasPre && !b.hasPre) return false;
+  if (!a.hasPre && !b.hasPre) return true;
+  // Both pre-release: compare tag then number (rc > beta, beta.10 > beta.9)
+  if (a.preTag !== b.preTag) return a.preTag > b.preTag;
+  return a.preNum >= b.preNum;
+}
+
+function needsReinstall() {
+  if (!fs.existsSync(binaryPath)) return true;
+  try {
+    const out = execFileSync(binaryPath, ["--version"], { encoding: "utf8", timeout: 5000 });
+    if (out.includes(EXPECTED_VER)) return false;
+    // Extract version from output (e.g. "heron-connect 1.2.2-beta.1" or "1.2.2-beta.1")
+    const match = out.match(/(\d+\.\d+\.\d+[^\s]*)/);
+    if (match && isNewerOrEqual(match[1], EXPECTED_VER)) return false;
+    return true;
+  } catch {
+    return true;
+  }
+}
+
+if (needsReinstall()) {
+  console.log(`[heron-connect] Binary missing or outdated, installing v${EXPECTED_VER}...`);
+  try {
+    execSync("node " + JSON.stringify(path.join(__dirname, "install.js")), {
+      stdio: "inherit",
+      cwd: __dirname,
+    });
+  } catch {
+    console.error("[heron-connect] Auto-install failed. Run manually: npm uninstall -g @qinghuangniao/heron-connect && npm install -g @qinghuangniao/heron-connect");
+    process.exit(1);
+  }
+}
+
+try {
+  execFileSync(binaryPath, process.argv.slice(2), { stdio: "inherit" });
+} catch (err) {
+  process.exit(err.status || 1);
+}