@sns-myagent/cli 0.3.0 → 0.3.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@sns-myagent/cli",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "SNS-MyAgent — Pi Agent size, full features. BYOK coding agent CLI.",
   "homepage": "https://github.com/Reihantt6/sns-myagent",
   "author": "Reihantt6",
@@ -106,6 +106,7 @@
   },
   "files": [
     "src",
+    "bin",
     "dist/cli.js",
     "dist/*.node",
     "scripts",

package/scripts/fetch-binary.mjs

@@ -1,34 +1,22 @@
 #!/usr/bin/env node
-// fetch-binary.mjs — Node.js postinstall for @sns-myagent/cli (Opsi B: dual-runtime npm support)
+// fetch-binary.mjs — Node.js postinstall for @sns-myagent/cli
 //
 // Downloads the prebuilt `snscoder` binary from the latest GitHub release
-// and unpacks it to <repo>/bin/. Runs under plain Node 18+ (no `npm install`
-// dependencies allowed — npm postinstall executes BEFORE package deps install).
+// into <prefix>/bin/, then symlinks the active one to <prefix>/bin/snscoder
+// so `npm install -g @sns-myagent/cli` puts a working `snscoder` on PATH.
 //
-// Strategy:
-//   1. Detect platform + arch (process.platform, process.arch).
-//   2. On linux, attempt a musl probe via `ldd /proc/self/exe` — if no glibc
-//      dependency is reported we pick the musl asset, otherwise the glibc one.
-//      If the probe fails or is inconclusive, fall back to glibc.
-//   3. GET https://api.github.com/repos/Reihantt6/sns-myagent/releases/latest
-//      (honors GITHUB_TOKEN env var for 60-req/hr anonymous → 5000-req/hr auth).
-//   4. Find the matching asset, download its zip, and unpack into bin/.
-//      Unix uses `unzip -o`; Windows uses `Expand-Archive` via PowerShell.
-//   5. chmod 755 the resulting binary on unix.
-//   6. On any failure path (no release, missing asset, network down) print a
-//      friendly warning and exit 0 — we must NOT break `npm install`.
+// Asset layout matches what .github/workflows/build-release.yml produces:
+//   snscoder-linux-x64          (raw, not zipped)
+//   snscoder-linux-arm64
+//   snscoder-darwin-x64
+//   snscoder-darwin-arm64
+//   snscoder-windows-x64.exe
 //
-// Spec conventions assumed for release assets (Bun-style):
-//   snscoder-linux-x64.zip       (glibc fallback)
-//   snscoder-linux-x64-musl.zip  (musl/alpine)
-//   snscoder-linux-arm64.zip
-//   snscoder-darwin-x64.zip
-//   snscoder-darwin-arm64.zip
-//   snscoder-windows-x64.zip
-//   Each archive contains a single file named `snscoder` (or `snscoder.exe`).
+// Falls back to musl variant on Linux if glibc asset unavailable.
+// Never breaks `npm install` — on any failure prints warning + exits 0.
 
 import { execFileSync } from "node:child_process";
-import { createWriteStream, existsSync, mkdirSync } from "node:fs";
+import { createWriteStream, existsSync, lstatSync, mkdirSync, symlinkSync, unlinkSync } from "node:fs";
 import { chmod, mkdtemp, readdir, rm, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, dirname, resolve } from "node:path";
@@ -37,147 +25,89 @@ import https from "node:https";
 
 const REPO = "Reihantt6/sns-myagent";
 const RELEASE_API = `https://api.github.com/repos/${REPO}/releases/latest`;
-const UA = "sns-myagent-fetch-binary/0.1.0 (npm postinstall)";
+const UA = "sns-myagent-fetch-binary/0.2.0 (npm postinstall)";
 
-// Resolve repo root: this script lives at <repo>/scripts/fetch-binary.mjs
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+// npm install -g layout: <prefix>/lib/node_modules/@sns-myagent/cli/scripts/fetch-binary.mjs
+// <prefix>/lib/node_modules/@sns-myagent/cli/node_modules/.bin/snscoder  (npm symlinks bin)
+// We want to download into <prefix>/lib/node_modules/@sns-myagent/cli/bin/
+// so npm auto-symlinks it into <prefix>/bin/snscoder.
 const REPO_ROOT = resolve(__dirname, "..");
 const BIN_DIR = join(REPO_ROOT, "bin");
 
 const isWin = process.platform === "win32";
 
-// --- Pretty logging ---------------------------------------------------------
-
 const c = {
 	reset: "\u001b[0m",
-	dim: "\u001b[2m",
 	red: "\u001b[31m",
 	green: "\u001b[32m",
 	yellow: "\u001b[33m",
 	cyan: "\u001b[36m",
-	bold: "\u001b[1m",
 };
+const info = (m) => process.stdout.write(`${c.cyan}info${c.reset}  ${m}\n`);
+const warn = (m) => process.stdout.write(`${c.yellow}warn${c.reset}  ${m}\n`);
+const err = (m) => process.stdout.write(`${c.red}error${c.reset} ${m}\n`);
+const ok = (m) => process.stdout.write(`${c.green}ok${c.reset}    ${m}\n`);
 
-function info(msg) {
-	process.stdout.write(`${c.cyan}info${c.reset}  ${msg}\n`);
-}
-function warn(msg) {
-	process.stdout.write(`${c.yellow}warn${c.reset}  ${msg}\n`);
-}
-function error(msg) {
-	process.stdout.write(`${c.red}error${c.reset} ${msg}\n`);
-}
-function ok(msg) {
-	process.stdout.write(`${c.green}ok${c.reset}    ${msg}\n`);
-}
-
-// --- Platform / asset mapping ----------------------------------------------
-
-/**
- * Map (platform, arch, isMusl) → asset filename.
- * Returns null when the platform/arch combo is unsupported.
- */
 function pickAssetName(platform, arch, isMusl) {
+	const x = (a) => (a === "x64" ? "x64" : a === "arm64" ? "arm64" : null);
 	if (platform === "linux") {
-		if (arch === "x64") return isMusl ? "snscoder-linux-x64-musl.zip" : "snscoder-linux-x64.zip";
-		if (arch === "arm64") return "snscoder-linux-arm64.zip";
-		return null;
+		const a = x(arch);
+		if (!a) return null;
+		// Release ships glibc variant by default. If user is on musl/alpine,
+		// try musl fallback (may 404 on releases that don't have it).
+		return isMusl ? [`snscoder-linux-${a}-musl`, `snscoder-linux-${a}`] : [`snscoder-linux-${a}`];
 	}
 	if (platform === "darwin") {
-		if (arch === "x64") return "snscoder-darwin-x64.zip";
-		if (arch === "arm64") return "snscoder-darwin-arm64.zip";
-		return null;
+		const a = x(arch);
+		if (!a) return null;
+		return [`snscoder-darwin-${a}`];
 	}
 	if (platform === "win32") {
-		if (arch === "x64") return "snscoder-windows-x64.zip";
-		return null;
+		return arch === "x64" ? [`snscoder-windows-x64.exe`] : null;
 	}
 	return null;
 }
 
-/**
- * Musl heuristic: run `ldd /proc/self/exe` and look for `libc.so.*` (glibc).
- * - musl systems (Alpine, Void with musl, etc.) print "Not a valid dynamic
- *   program" or `ldd: can't find dynamic linker info` AND no `libc.so.6` line.
- * - glibc systems show `libc.so.6 => /lib64/libc.so.6` etc.
- *
- * Heuristic limitations:
- * - Static binaries report "not a dynamic executable" — we conservatively
- *   treat that as glibc (more common on developer machines).
- * - BusyBox `ldd` is a shell wrapper; it sometimes prints to stdout but not
- *   stderr. We merge both streams before scanning.
- */
 function detectMuslLinux() {
 	if (process.platform !== "linux") return false;
 	try {
-		const out = execFileSync("ldd", ["/proc/self/exe"], {
-			stdio: ["ignore", "pipe", "pipe"],
-			encoding: "utf8",
-			timeout: 3000,
-		});
-		// glibc leaves a libc.so.6 line; musl leaves musl libc.so line.
+		const out = execFileSync("ldd", ["/proc/self/exe"], { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8", timeout: 3000 });
 		if (/libc\.so\.6/.test(out)) return false;
 		if (/musl/.test(out)) return true;
-		// No glibc marker found and not explicitly musl → assume musl
-		// (Alpine, Void-musl, etc.). Falls back wrong on static binaries
-		// — see heuristic note above.
-		return true;
+		return true; // alpine/void default to musl
 	} catch {
-		// ldd missing OR failed → can't tell. Default to glibc (most common).
-		return false;
+		return false; // can't tell — glibc default
 	}
 }
 
-// --- HTTP helpers -----------------------------------------------------------
-
-/**
- * https.get wrapper that returns a Buffer and follows up to 3 redirects
- * (GitHub release redirects to S3, which redirects to Cloudfront).
- */
-function fetchBuffer(url, redirectsLeft = 3) {
+function fetchBuffer(url, redirectsLeft = 5) {
 	return new Promise((resolveP, rejectP) => {
-		const headers = {
-			"User-Agent": UA,
-			Accept: "application/octet-stream",
-		};
-		if (process.env.GITHUB_TOKEN) {
-			headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
-		}
-
+		const headers = { "User-Agent": UA, Accept: "application/octet-stream" };
+		if (process.env.GITHUB_TOKEN) headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
 		const req = https.get(url, { headers }, (res) => {
 			const status = res.statusCode ?? 0;
-			// Follow redirects (GitHub release downloads 302 to S3 → Cloudfront)
 			if (status >= 300 && status < 400 && res.headers.location) {
 				res.resume();
-				if (redirectsLeft <= 0) {
-					rejectP(new Error(`too many redirects for ${url}`));
-					return;
-				}
-				resolveP(fetchBuffer(res.headers.location, redirectsLeft - 1));
-				return;
+				if (redirectsLeft <= 0) return rejectP(new Error("too many redirects"));
+				return resolveP(fetchBuffer(res.headers.location, redirectsLeft - 1));
 			}
 			if (status === 404) {
 				res.resume();
-				rejectP(Object.assign(new Error("not found"), { httpStatus: 404 }));
-				return;
+				return rejectP(Object.assign(new Error("not found"), { httpStatus: 404 }));
 			}
 			if (status !== 200) {
 				res.resume();
-				rejectP(new Error(`HTTP ${status} for ${url}`));
-				return;
+				return rejectP(new Error(`HTTP ${status} for ${url}`));
 			}
-
 			const chunks = [];
 			res.on("data", (c2) => chunks.push(c2));
 			res.on("end", () => resolveP(Buffer.concat(chunks)));
 			res.on("error", rejectP);
 		});
-
 		req.on("error", rejectP);
-		req.setTimeout(30_000, () => {
-			req.destroy(new Error(`timeout after 30s: ${url}`));
-		});
+		req.setTimeout(60_000, () => req.destroy(new Error(`timeout 60s: ${url}`)));
 	});
 }
 
@@ -188,172 +118,131 @@ function fetchJson(url) {
 			Accept: "application/vnd.github+json",
 			"X-GitHub-Api-Version": "2022-11-28",
 		};
-		if (process.env.GITHUB_TOKEN) {
-			headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
-		}
-
+		if (process.env.GITHUB_TOKEN) headers.Authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
 		const req = https.get(url, { headers }, (res) => {
 			const status = res.statusCode ?? 0;
 			const chunks = [];
 			res.on("data", (c2) => chunks.push(c2));
 			res.on("end", () => {
 				const body = Buffer.concat(chunks).toString("utf8");
-				if (status === 404) {
-					rejectP(Object.assign(new Error("release not found"), { httpStatus: 404 }));
-					return;
-				}
-				if (status !== 200) {
-					rejectP(new Error(`GitHub API HTTP ${status}: ${body.slice(0, 200)}`));
-					return;
-				}
+				if (status === 404) return rejectP(Object.assign(new Error("release not found"), { httpStatus: 404 }));
+				if (status === 403) return rejectP(Object.assign(new Error("rate limited"), { httpStatus: 403 }));
+				if (status !== 200) return rejectP(new Error(`GitHub API HTTP ${status}: ${body.slice(0, 200)}`));
 				try {
 					resolveP(JSON.parse(body));
 				} catch (e) {
-					rejectP(new Error(`invalid JSON from GitHub: ${e.message}`));
+					rejectP(new Error(`invalid JSON: ${e.message}`));
 				}
 			});
-			res.on("error", rejectP);
 		});
-
 		req.on("error", rejectP);
-		req.setTimeout(30_000, () => {
-			req.destroy(new Error(`timeout after 30s: ${url}`));
-		});
+		req.setTimeout(30_000, () => req.destroy(new Error(`timeout 30s: ${url}`)));
 	});
 }
 
-// --- Zip unpack (delegates to system tools) --------------------------------
-
-/**
- * Unzip an archive into destDir. On unix uses `unzip -o`; on Windows uses
- * PowerShell's `Expand-Archive`. Both are preinstalled on the respective
- * platforms (unzip is on virtually every macOS/Linux dev box; Expand-Archive
- * ships with PowerShell 5+).
- *
- * Throws if neither tool is available — caller decides whether that's fatal.
- */
-function unzip(archivePath, destDir) {
-	if (isWin) {
-		// PowerShell Expand-Archive needs a non-existent OR empty dest dir.
-		execFileSync(
-			"powershell.exe",
-			[
-				"-NoProfile",
-				"-NonInteractive",
-				"-Command",
-				`Expand-Archive -Path '${archivePath.replace(/'/g, "''")}' -DestinationPath '${destDir.replace(/'/g, "''")}' -Force`,
-			],
-			{ stdio: ["ignore", "inherit", "inherit"] },
-		);
-	} else {
-		execFileSync("unzip", ["-o", archivePath, "-d", destDir], {
-			stdio: ["ignore", "inherit", "inherit"],
-		});
-	}
-}
-
-// --- Main flow --------------------------------------------------------------
-
 async function main() {
 	const platform = process.platform;
 	const arch = process.arch;
 	const isMusl = detectMuslLinux();
-	const assetName = pickAssetName(platform, arch, isMusl);
+	const candidates = pickAssetName(platform, arch, isMusl);
 
-	if (!assetName) {
-		warn(
-			`unsupported platform/arch combo: ${platform}/${arch}. ` +
-				`Build from source instead: https://github.com/${REPO}#from-source`,
-		);
+	if (!candidates) {
+		warn(`unsupported platform/arch: ${platform}/${arch}. Build from source: https://github.com/${REPO}#from-source`);
 		return;
 	}
 
-	info(`target: ${platform}/${arch}${isMusl ? " (musl)" : ""} → ${assetName}`);
+	info(`target: ${platform}/${arch}${isMusl ? " (musl)" : ""}`);
 
 	let release;
 	try {
 		release = await fetchJson(RELEASE_API);
 	} catch (e) {
 		if (e.httpStatus === 404) {
-			warn(
-				`no release found at github.com/${REPO}/releases — ` +
-					`maintainer must publish v0.1.0 first. Falling back to Bun install.`,
-			);
-			return;
+			warn(`no release at github.com/${REPO}/releases. Falling back to Bun install.`);
+		} else if (e.httpStatus === 403) {
+			warn(`GitHub API rate-limited. Set GITHUB_TOKEN env var to retry. Falling back to Bun install.`);
+		} else {
+			warn(`could not reach GitHub API (${e.message}). Skipping binary fetch.`);
 		}
-		warn(
-			`could not reach GitHub API (${e.message}). ` +
-				`Skipping binary fetch. Run 'npm rebuild' after going online.`,
-		);
 		return;
 	}
 
-	const asset = (release.assets ?? []).find((a) => a.name === assetName);
-	if (!asset || !asset.browser_download_url) {
+	const available = release.assets ?? [];
+	const asset =
+		candidates.map((n) => available.find((a) => a.name === n)).find(Boolean) ?? null;
+
+	if (!asset?.browser_download_url) {
 		warn(
-			`release ${release.tag_name ?? "(unknown)"} has no asset '${assetName}'. ` +
-				`Available: ${(release.assets ?? []).map((a) => a.name).join(", ") || "(none)"}. ` +
-				`Falling back to Bun install.`,
+			`release ${release.tag_name ?? "(unknown)"} has no matching asset. ` +
+				`Wanted one of: ${candidates.join(", ")}. Available: ${available.map((a) => a.name).join(", ") || "(none)"}.`,
 		);
 		return;
 	}
 
-	// Download into a temp dir so a half-finished install never clobbers bin/.
 	const tmp = await mkdtemp(join(tmpdir(), "snscoder-"));
-	const archivePath = join(tmp, assetName);
-	info(`downloading ${asset.browser_download_url}`);
+	const tmpFile = join(tmp, asset.name);
+	info(`downloading ${asset.name} (${(asset.size / 1024 / 1024).toFixed(2)} MB)`);
 
-	let zipBuf;
+	let buf;
 	try {
-		zipBuf = await fetchBuffer(asset.browser_download_url);
+		buf = await fetchBuffer(asset.browser_download_url);
 	} catch (e) {
-		warn(`download failed (${e.message}). Skipping binary fetch.`);
+		warn(`download failed: ${e.message}`);
 		await rm(tmp, { recursive: true, force: true });
 		return;
 	}
 
 	await new Promise((resolveP, rejectP) => {
-		const ws = createWriteStream(archivePath);
+		const ws = createWriteStream(tmpFile);
 		ws.on("error", rejectP);
 		ws.on("finish", resolveP);
-		ws.end(zipBuf);
+		ws.end(buf);
 	});
 
-	info(`extracting → ${BIN_DIR}`);
 	mkdirSync(BIN_DIR, { recursive: true });
-	try {
-		unzip(archivePath, BIN_DIR);
-	} catch (e) {
-		warn(`unzip failed (${e.message}). Binaries like 'unzip' or PowerShell Expand-Archive are required.`);
-		await rm(tmp, { recursive: true, force: true });
-		return;
+	const target = join(BIN_DIR, asset.name);
+	if (existsSync(target)) {
+		try {
+			unlinkSync(target);
+		} catch {}
 	}
 
-	const binaryName = isWin ? "snscoder.exe" : "snscoder";
-	const binaryPath = join(BIN_DIR, binaryName);
+	// Move from tmp into bin/
+	const { copyFile } = await import("node:fs/promises");
+	await copyFile(tmpFile, target);
+	await rm(tmp, { recursive: true, force: true });
 
-	if (!existsSync(binaryPath)) {
-		// Sometimes archives use a different internal name — try to discover.
-		const entries = await readdir(BIN_DIR);
-		warn(
-			`expected '${binaryName}' in archive but found: ${entries.join(", ") || "(empty)"}. ` +
-				`Adjust scripts/fetch-binary.mjs to match the release asset layout.`,
-		);
-		await rm(tmp, { recursive: true, force: true });
-		return;
+	if (!isWin) {
+		await chmod(target, 0o755);
 	}
 
-	if (!isWin) {
-		await chmod(binaryPath, 0o755);
+	// Symlink: bin/snscoder → bin/<asset-name> (so `snscoder` works on PATH)
+	// npm install -g creates bin/<name> symlinks for the entries in package.json "bin"
+	// (which is "snscoder" → "bin/snscoder.js"). We don't have that shim; instead
+	// we create a wrapper file bin/snscoder.js that exec's the platform binary.
+	const shim = isWin ? "snscoder.cmd" : "snscoder.js";
+	const shimPath = join(BIN_DIR, shim);
+
+	if (isWin) {
+		const { writeFileSync } = await import("node:fs");
+		writeFileSync(
+			shimPath,
+			`@echo off\r\n"%~dp0${asset.name}" %*\r\n`,
+		);
+	} else {
+		const { writeFileSync } = await import("node:fs");
+		writeFileSync(
+			shimPath,
+			`#!/usr/bin/env node\n// Auto-generated by fetch-binary.mjs — execs the platform binary.\nimport { spawn } from "node:child_process";\nimport { fileURLToPath } from "node:url";\nimport { dirname, join } from "node:path";\nconst here = dirname(fileURLToPath(import.meta.url));\nconst bin = join(here, "${asset.name}");\nconst r = spawn(bin, process.argv.slice(2), { stdio: "inherit" });\nr.on("exit", (c) => process.exit(c ?? 0));\n`,
+		);
+		await chmod(shimPath, 0o755);
 	}
-	const st = await stat(binaryPath);
-	ok(`${binaryName} ready (${(st.size / 1024 / 1024).toFixed(2)} MB)`);
 
-	await rm(tmp, { recursive: true, force: true });
+	const st = await stat(target);
+	ok(`${asset.name} ready (${(st.size / 1024 / 1024).toFixed(2)} MB) → bin/${shim}`);
 }
 
 main().catch((e) => {
-	// Catch-all: never break npm install. Print + exit 0.
-	error(`unexpected: ${e?.stack ?? e?.message ?? e}`);
-	process.exit(0);
+	err(`unexpected: ${e?.stack ?? e?.message ?? e}`);
+	process.exit(0); // never break npm install
 });

package/scripts/smoke-test.sh

@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# SNS-MyAgent E2E smoke test
+# Runs against a freshly built binary to verify all critical paths work.
+# Usage: ./scripts/smoke-test.sh [path-to-binary]
+# Exit 0 on PASS, 1 on any FAIL.
+#
+# NOTE: Binary may exit 1 in JS-only fallback mode (pi_natives missing on CI
+# runner). We check stdout content rather than strict exit code for those.
+
+set -uo pipefail
+
+BIN="${1:-./bin/snscoder-linux-x64}"
+FAIL=0
+PASS=0
+
+# run_check <label> <expect-exit> <cmd...>
+# - exit code MUST match expect-exit for PASS
+run_check() {
+	local label="$1"
+	local expect_code="$2"
+	shift 2
+	local out
+	out=$("$BIN" "$@" 2>&1)
+	local actual=$?
+	if [[ $actual -eq $expect_code ]]; then
+		echo "✓ $label"
+		PASS=$((PASS + 1))
+	else
+		echo "✗ $label (expected exit $expect_code, got $actual)"
+		echo "  output: ${out:0:200}"
+		FAIL=$((FAIL + 1))
+	fi
+}
+
+# run_loose <label> <expect-substring-in-stdout> <cmd...>
+# - tolerates exit 0 OR 1 (JS-only fallback)
+# - just checks stdout/stderr contains the substring
+run_loose() {
+	local label="$1"
+	local needle="$2"
+	shift 2
+	local out
+	out=$("$BIN" "$@" 2>&1)
+	if [[ "$out" == *"$needle"* ]]; then
+		echo "✓ $label"
+		PASS=$((PASS + 1))
+	else
+		echo "✗ $label (missing '$needle' in output)"
+		echo "  output: ${out:0:200}"
+		FAIL=$((FAIL + 1))
+	fi
+}
+
+echo "=== SNS-MyAgent E2E smoke test ==="
+echo "Binary: $BIN"
+echo ""
+
+if [[ ! -f "$BIN" ]]; then
+	echo "✗ binary not found: $BIN"
+	exit 1
+fi
+
+# Version: pi_natives may be missing on CI runner → JS-only fallback may exit 1
+# but version text still prints. Check substring rather than exit code.
+run_loose "version flag prints version" "snscoder " --version
+run_loose "version subcommand prints version" "snscoder " version
+
+# Help: help uses only built-in code, should exit 0 reliably
+run_check "help flag" 0 --help
+run_check "help subcommand" 0 help
+
+# Init (skips if config exists)
+run_check "init (idempotent)" 0 init
+
+# Config subcommands — may also be affected by js-only
+run_loose "config show" "model" config show
+
+# Orchestrate (stub returns exit 2 with clear message)
+run_loose "orchestrate shows clear stub message" "agent executor not wired" orchestrate "test prompt"
+
+# Unknown command — exit 1 guaranteed
+run_check "unknown command (exit 1)" 1 nonexistent-command
+
+echo ""
+echo "=== Summary ==="
+echo "  PASS: $PASS"
+echo "  FAIL: $FAIL"
+
+if [[ $FAIL -gt 0 ]]; then
+	exit 1
+fi
+exit 0