@obedience-corp/agent-stream-dbg 0.1.1

package/README.md

@@ -0,0 +1,37 @@
+# @obedience-corp/agent-stream-dbg
+
+npm distribution of the [agent-stream-dbg](https://github.com/Obedience-Corp/agent-stream-dbg) Go CLI.
+
+Same model as [`@obedience-corp/festival`](https://www.npmjs.com/package/@obedience-corp/festival):
+on install, download the matching GitHub Release archive and verify `checksums.txt`.
+
+## Install
+
+```bash
+npm install -g @obedience-corp/agent-stream-dbg
+npx @obedience-corp/agent-stream-dbg --help
+```
+
+Also works with pnpm / bun.
+
+## Requirements
+
+- Node.js 18+
+- macOS or Linux (`x64` / `arm64`)
+- Network access to GitHub Releases on install
+
+## Alternatives
+
+```bash
+go install github.com/Obedience-Corp/agent-stream-dbg/cmd/agent-stream-dbg@latest
+
+brew tap Obedience-Corp/tap
+brew trust Obedience-Corp/tap
+brew install agent-stream-dbg
+```
+
+## Maintainers
+
+Releases are automated via GoReleaser + this package’s `scripts/publish_npm_package.sh`
+(on tag push). Do not hand-edit package version on `main` (stays `0.0.0`); publish
+sets the version from the git tag.

package/bin/agent-stream-dbg

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+const { runBinary } = require("../lib/run");
+
+runBinary().catch((err) => {
+  console.error(`Failed to run agent-stream-dbg: ${err.message}`);
+  process.exit(1);
+});

package/install.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+// Festival-style npm installer: download GoReleaser archive + checksums.txt.
+
+const crypto = require("crypto");
+const fs = require("fs");
+const https = require("https");
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+const REPO = "Obedience-Corp/agent-stream-dbg";
+const BINARY = "agent-stream-dbg";
+const DOWNLOAD_ATTEMPTS = 3;
+const DOWNLOAD_TIMEOUT_MS = 60_000;
+const RETRY_BASE_DELAY_MS = 750;
+
+const PLATFORM_MAP = {
+  darwin: "macOS",
+  linux: "linux",
+};
+
+const ARCH_MAP = {
+  x64: "x86_64",
+  arm64: "arm64",
+};
+
+function packageVersion() {
+  return require("./package.json").version;
+}
+
+function releaseTag(version = packageVersion()) {
+  return `v${version}`;
+}
+
+function targetForCurrentPlatform() {
+  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: macOS/Linux x64/arm64.`,
+    );
+  }
+  return `${platform}-${arch}`;
+}
+
+function archiveName(version = packageVersion()) {
+  return `agent-stream-dbg-${version}-${targetForCurrentPlatform()}.tar.gz`;
+}
+
+function releaseURL(asset, version = packageVersion()) {
+  return `https://github.com/${REPO}/releases/download/${releaseTag(version)}/${asset}`;
+}
+
+function binaryPath() {
+  const name =
+    process.platform === "win32" ? `${BINARY}.exe` : `${BINARY}-bin`;
+  return path.join(__dirname, "bin", name);
+}
+
+function haveInstallArtifacts() {
+  return fs.existsSync(binaryPath());
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function downloadOnce(url, dest) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const fail = (err) => {
+      if (settled) return;
+      settled = true;
+      fs.rmSync(dest, { force: true });
+      reject(err);
+    };
+    const done = () => {
+      if (settled) return;
+      settled = true;
+      resolve();
+    };
+
+    const follow = (nextURL, redirects = 0) => {
+      if (redirects > 10) {
+        fail(new Error("too many redirects"));
+        return;
+      }
+      const request = https
+        .get(
+          nextURL,
+          { headers: { "User-Agent": "agent-stream-dbg-npm" } },
+          (response) => {
+            if (
+              response.statusCode >= 300 &&
+              response.statusCode < 400 &&
+              response.headers.location
+            ) {
+              response.resume();
+              follow(response.headers.location, redirects + 1);
+              return;
+            }
+            if (response.statusCode !== 200) {
+              response.resume();
+              fail(
+                new Error(
+                  `failed to download ${url}: HTTP ${response.statusCode}`,
+                ),
+              );
+              return;
+            }
+            const file = fs.createWriteStream(dest);
+            response.pipe(file);
+            file.on("finish", () => file.close(done));
+            file.on("error", fail);
+          },
+        )
+        .on("error", fail);
+      request.setTimeout(DOWNLOAD_TIMEOUT_MS, () => {
+        request.destroy(
+          new Error(`download timeout after ${DOWNLOAD_TIMEOUT_MS / 1000}s`),
+        );
+      });
+    };
+    follow(url);
+  });
+}
+
+async function download(url, dest, attempts = DOWNLOAD_ATTEMPTS) {
+  let lastErr;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      await downloadOnce(url, dest);
+      return;
+    } catch (err) {
+      lastErr = err;
+      if (attempt === attempts) break;
+      const delay = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
+      console.warn(
+        `Download failed (${attempt}/${attempts}) for ${path.basename(dest)}: ${err.message}. Retrying in ${delay}ms...`,
+      );
+      await sleep(delay);
+    }
+  }
+  throw lastErr;
+}
+
+function sha256(filePath) {
+  return crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+}
+
+function expectedChecksum(checksumsPath, filename) {
+  for (const line of fs.readFileSync(checksumsPath, "utf8").split(/\r?\n/)) {
+    const parts = line.trim().split(/\s+/);
+    if (parts.length >= 2 && parts[1] === filename) {
+      return parts[0];
+    }
+  }
+  throw new Error(`checksum for ${filename} not found in checksums.txt`);
+}
+
+function verifyChecksum(archivePath, checksumsPath, filename) {
+  const expected = expectedChecksum(checksumsPath, filename);
+  const actual = sha256(archivePath);
+  if (actual !== expected) {
+    throw new Error(
+      `checksum mismatch for ${filename}: expected ${expected}, got ${actual}`,
+    );
+  }
+}
+
+function extractArchive(archivePath, destDir) {
+  const result = spawnSync("tar", ["-xzf", archivePath, "-C", destDir], {
+    stdio: "inherit",
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(`tar exited with status ${result.status}`);
+  }
+}
+
+async function install(options = {}) {
+  const force = options.force === true;
+  if (!force && haveInstallArtifacts()) {
+    return;
+  }
+
+  const version = packageVersion();
+  if (version === "0.0.0") {
+    throw new Error(
+      "package version is 0.0.0 (dev checkout). Publish a release or install with Go/Homebrew.",
+    );
+  }
+
+  const filename = archiveName(version);
+  const binDir = path.join(__dirname, "bin");
+  const tempDir = path.join(__dirname, ".tmp-extract");
+  const archivePath = path.join(__dirname, filename);
+  const checksumsPath = path.join(__dirname, "checksums.txt");
+
+  console.log(
+    `Installing agent-stream-dbg ${version} (${targetForCurrentPlatform()})...`,
+  );
+
+  fs.mkdirSync(binDir, { recursive: true });
+  fs.rmSync(tempDir, { recursive: true, force: true });
+  fs.mkdirSync(tempDir, { recursive: true });
+
+  try {
+    await download(releaseURL(filename, version), archivePath);
+    await download(releaseURL("checksums.txt", version), checksumsPath);
+    verifyChecksum(archivePath, checksumsPath, filename);
+    extractArchive(archivePath, tempDir);
+
+    const extractedPath = path.join(tempDir, BINARY);
+    const targetPath = binaryPath();
+    if (!fs.existsSync(extractedPath)) {
+      throw new Error(`${BINARY} not found in ${filename}`);
+    }
+    fs.renameSync(extractedPath, targetPath);
+    if (process.platform !== "win32") {
+      fs.chmodSync(targetPath, 0o755);
+    }
+    console.log("Installed agent-stream-dbg successfully");
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    fs.rmSync(archivePath, { force: true });
+    fs.rmSync(checksumsPath, { force: true });
+  }
+}
+
+async function main() {
+  try {
+    await install({ force: false });
+  } catch (err) {
+    console.error(`Failed to install agent-stream-dbg: ${err.message}`);
+    console.error(
+      [
+        "",
+        "Fallbacks:",
+        "  go install github.com/Obedience-Corp/agent-stream-dbg/cmd/agent-stream-dbg@latest",
+        "  brew tap Obedience-Corp/tap && brew trust Obedience-Corp/tap && brew install agent-stream-dbg",
+        "",
+      ].join("\n"),
+    );
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  archiveName,
+  binaryPath,
+  install,
+  targetForCurrentPlatform,
+};

package/lib/run.js

@@ -0,0 +1,27 @@
+const fs = require("fs");
+const { spawnSync } = require("child_process");
+
+const { binaryPath, install } = require("../install");
+
+async function runBinary() {
+  const target = binaryPath();
+
+  if (!fs.existsSync(target)) {
+    await install();
+  }
+
+  const result = spawnSync(target, process.argv.slice(2), {
+    stdio: "inherit",
+    shell: false,
+  });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  process.exit(result.status ?? 1);
+}
+
+module.exports = {
+  runBinary,
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@obedience-corp/agent-stream-dbg",
+  "version": "0.1.1",
+  "description": "TUI debugger for multi-agent event streams (SSE, gRPC, ACP) — Go binary via npm",
+  "license": "Apache-2.0",
+  "author": "Obedience Corp",
+  "homepage": "https://github.com/Obedience-Corp/agent-stream-dbg#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Obedience-Corp/agent-stream-dbg.git",
+    "directory": "npm"
+  },
+  "bugs": {
+    "url": "https://github.com/Obedience-Corp/agent-stream-dbg/issues"
+  },
+  "keywords": [
+    "agents",
+    "debugging",
+    "tui",
+    "grpc",
+    "sse",
+    "acp",
+    "cli"
+  ],
+  "bin": {
+    "agent-stream-dbg": "bin/agent-stream-dbg"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "files": [
+    "README.md",
+    "bin",
+    "install.js",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "os": [
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}