agent-notify 0.2.5 → 0.3.0

package/bin/agent-notify.js

@@ -1,56 +1,96 @@
 #!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { getPlatformTarget } = require('../lib/platform');
+const { extractSemver, compareVersions } = require('../lib/version');
+const { getInstalledBinaryPath, TMP_DIR } = require('../lib/constants');
+const { buildAssetName, buildDownloadUrl } = require('../lib/release');
+const { downloadToFile } = require('../lib/download');
+const { installFromArchive } = require('../lib/install');
+const { runBinary } = require('../lib/run');
 
-const { spawn } = require('child_process');
-const { execSync } = require('child_process');
-const path = require('path');
-const os = require('os');
-const fs = require('fs');
-
-function getBinaryDir() {
-  // Try to get npm global bin directory
-  // npm bin -g is deprecated, use npm prefix -g instead
-  try {
-    const prefix = execSync('npm prefix -g', { encoding: 'utf8' }).trim();
-    return path.join(prefix, 'bin');
-  } catch (e) {
-    // Fallback to ~/.local/bin
-    return path.join(os.homedir(), '.local', 'bin');
-  }
+function getDesiredVersion() {
+  return require('../package.json').version;
 }
 
-const BINARY_DIR = getBinaryDir();
+function getInstalledVersion(binaryPath) {
+  const result = spawnSync(binaryPath, ['--version'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  if (result.error || result.status !== 0) {
+    return null;
+  }
 
-function getBinaryName() {
-  return os.platform() === 'win32' ? 'agent-notify.exe' : 'agent-notify';
+  return extractSemver(result.stdout);
 }
 
-function getBinaryPath() {
-  return path.join(BINARY_DIR, getBinaryName());
+async function downloadAndInstall(version, target, binaryPath) {
+  fs.mkdirSync(TMP_DIR, { recursive: true });
+
+  const assetName = buildAssetName(version, target);
+  const archivePath = path.join(TMP_DIR, assetName);
+  const binaryNameInArchive = `agent-notify-v${version}-${target.goos}-${target.goarch}${target.ext}`;
+
+  await downloadToFile(buildDownloadUrl(version, assetName), archivePath);
+  return installFromArchive({
+    archivePath,
+    installDir: path.dirname(binaryPath),
+    binaryNameInArchive,
+    finalBinaryName: path.basename(binaryPath),
+  });
 }
 
-function run() {
-  const binaryPath = getBinaryPath();
+async function main(argv, deps = {}) {
+  const desiredVersion = (deps.getDesiredVersion || getDesiredVersion)();
+  const target = (deps.getPlatformTarget || getPlatformTarget)();
+  const binaryPath = (deps.getInstalledBinaryPath || getInstalledBinaryPath)(target);
+  const pathExists = deps.pathExists || fs.existsSync;
+  const getVersion = deps.getInstalledVersion || getInstalledVersion;
+  const compare = deps.compareVersions || compareVersions;
+  const install = deps.downloadAndInstall || ((version, releaseTarget) => downloadAndInstall(version, releaseTarget, binaryPath));
+  const run = deps.runBinary || runBinary;
+  const warn = deps.warn || ((message) => console.warn(message));
 
-  if (!fs.existsSync(binaryPath)) {
-    console.error(`Binary not found at ${binaryPath}`);
-    console.error('Please run: npm install or npx @hellolib/agent-notify');
-    process.exit(1);
+  let installedVersion = null;
+  const hasInstalledBinary = pathExists(binaryPath);
+  if (hasInstalledBinary) {
+    installedVersion = getVersion(binaryPath);
   }
+  const canFallbackToInstalledBinary = Boolean(installedVersion);
 
-  const args = process.argv.slice(2);
-  const child = spawn(binaryPath, args, {
-    stdio: 'inherit',
-    env: process.env
-  });
+  const needsInstall = !hasInstalledBinary || !installedVersion || compare(installedVersion, desiredVersion) < 0;
 
-  child.on('exit', (code) => {
-    process.exit(code || 0);
-  });
+  if (needsInstall) {
+    try {
+      await install(desiredVersion, target, binaryPath);
+    } catch (error) {
+      if (!canFallbackToInstalledBinary) {
+        throw error;
+      }
+      warn(`failed to update agent-notify: ${error.message}`);
+    }
+  }
 
-  child.on('error', (err) => {
-    console.error(`Failed to run binary: ${err.message}`);
-    process.exit(1);
-  });
+  return run(binaryPath, argv);
+}
+
+if (require.main === module) {
+  main(process.argv.slice(2))
+    .then((code) => {
+      process.exitCode = code;
+    })
+    .catch((error) => {
+      console.error(error.message);
+      process.exitCode = 1;
+    });
 }
 
-run();
+module.exports = {
+  main,
+  downloadAndInstall,
+  getDesiredVersion,
+  getInstalledVersion,
+};

package/lib/constants.js

@@ -0,0 +1,19 @@
+const path = require('node:path');
+const os = require('node:os');
+
+const REPO_OWNER = 'hellolib';
+const REPO_NAME = 'agent-notify';
+const INSTALL_DIR = path.join(os.homedir(), '.agent-notify');
+const TMP_DIR = path.join(INSTALL_DIR, 'tmp');
+
+function getInstalledBinaryPath(target) {
+  return path.join(INSTALL_DIR, `agent-notify${target.ext}`);
+}
+
+module.exports = {
+  REPO_OWNER,
+  REPO_NAME,
+  INSTALL_DIR,
+  TMP_DIR,
+  getInstalledBinaryPath,
+};

package/lib/download.js

@@ -0,0 +1,57 @@
+const fs = require('node:fs');
+const https = require('node:https');
+
+function removeFileIfExists(filePath, callback) {
+  fs.rm(filePath, { force: true }, () => callback());
+}
+
+function downloadToFile(url, destinationPath, client = https) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destinationPath);
+
+    const request = client.get(url, {
+      timeout: 300000, // 300 seconds
+    }, (response) => {
+      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        const redirectUrl = new URL(response.headers.location, url).toString();
+        file.close(() => {
+          removeFileIfExists(destinationPath, () => {
+            downloadToFile(redirectUrl, destinationPath, client).then(resolve, reject);
+          });
+        });
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        file.close(() => {
+          removeFileIfExists(destinationPath, () => {
+            reject(new Error(`download failed: ${response.statusCode} ${url}`));
+          });
+        });
+        return;
+      }
+
+      response.pipe(file);
+      file.on('finish', () => file.close(() => resolve(destinationPath)));
+    });
+
+    request.on('error', (err) => {
+      file.close(() => {
+        removeFileIfExists(destinationPath, () => reject(err));
+      });
+    });
+
+    request.on('timeout', () => {
+      request.destroy();
+      file.close(() => {
+        removeFileIfExists(destinationPath, () => {
+          reject(new Error(`download timeout after 300s: ${url}`));
+        });
+      });
+    });
+  });
+}
+
+module.exports = {
+  downloadToFile,
+};

package/lib/install.js

@@ -0,0 +1,61 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const tar = require('tar');
+
+function isUnsafeArchivePath(entryPath) {
+  return path.isAbsolute(entryPath) || entryPath.split('/').includes('..');
+}
+
+async function installFromArchive({ archivePath, installDir, binaryNameInArchive, finalBinaryName }) {
+  fs.mkdirSync(installDir, { recursive: true });
+
+  const extractDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-notify-extract-'));
+  const finalPath = path.join(installDir, finalBinaryName);
+  const tempFinalPath = `${finalPath}.tmp`;
+
+  try {
+    const entries = [];
+    await tar.t({
+      file: archivePath,
+      gzip: true,
+      onReadEntry: (entry) => entries.push({ path: entry.path, type: entry.type }),
+    });
+
+    const binaryEntry = entries.find((entry) => entry.path === binaryNameInArchive);
+    if (!binaryEntry) {
+      throw new Error(`binary not found in archive: ${binaryNameInArchive}`);
+    }
+
+    if (binaryEntry.type !== 'File' || entries.some((entry) => isUnsafeArchivePath(entry.path))) {
+      throw new Error('unsafe archive contents');
+    }
+
+    await tar.x({
+      file: archivePath,
+      cwd: extractDir,
+      gzip: true,
+      filter: (entryPath) => entryPath === binaryNameInArchive,
+    });
+
+    const extractedPath = path.join(extractDir, binaryNameInArchive);
+    if (!fs.existsSync(extractedPath)) {
+      throw new Error(`binary not found in archive: ${binaryNameInArchive}`);
+    }
+
+    fs.copyFileSync(extractedPath, tempFinalPath);
+    if (process.platform !== 'win32') {
+      fs.chmodSync(tempFinalPath, 0o755);
+    }
+    fs.renameSync(tempFinalPath, finalPath);
+
+    return finalPath;
+  } finally {
+    fs.rmSync(tempFinalPath, { force: true });
+    fs.rmSync(extractDir, { recursive: true, force: true });
+  }
+}
+
+module.exports = {
+  installFromArchive,
+};

package/lib/platform.js

@@ -0,0 +1,29 @@
+function getPlatformTarget({ platform = process.platform, arch = process.arch } = {}) {
+  const goosMap = {
+    darwin: 'darwin',
+    linux: 'linux',
+    win32: 'windows',
+  };
+
+  const goarchMap = {
+    x64: 'amd64',
+    arm64: 'arm64',
+  };
+
+  const goos = goosMap[platform];
+  const goarch = goarchMap[arch];
+
+  if (!goos || !goarch) {
+    throw new Error(`unsupported platform: ${platform}/${arch}`);
+  }
+
+  return {
+    goos,
+    goarch,
+    ext: goos === 'windows' ? '.exe' : '',
+  };
+}
+
+module.exports = {
+  getPlatformTarget,
+};

package/lib/release.js

@@ -0,0 +1,21 @@
+const { REPO_OWNER, REPO_NAME } = require('./constants');
+
+function buildTag(version) {
+  return version.startsWith('v') ? version : `v${version}`;
+}
+
+function buildAssetName(version, target) {
+  const tag = buildTag(version);
+  return `agent-notify-${tag}-${target.goos}-${target.goarch}.tar.gz`;
+}
+
+function buildDownloadUrl(version, assetName) {
+  const tag = buildTag(version);
+  return `https://github.com/${REPO_OWNER}/${REPO_NAME}/releases/download/${tag}/${assetName}`;
+}
+
+module.exports = {
+  buildTag,
+  buildAssetName,
+  buildDownloadUrl,
+};

package/lib/run.js

@@ -0,0 +1,17 @@
+const { spawn } = require('node:child_process');
+
+function runBinary(binaryPath, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(binaryPath, args, {
+      stdio: 'inherit',
+      env: { ...process.env },
+    });
+
+    child.on('error', reject);
+    child.on('close', (code) => resolve(code ?? 1));
+  });
+}
+
+module.exports = {
+  runBinary,
+};

package/lib/version.js

@@ -0,0 +1,21 @@
+function extractSemver(output) {
+  const match = String(output).match(/v?(\d+\.\d+\.\d+)/);
+  return match ? match[1] : null;
+}
+
+function compareVersions(left, right) {
+  const l = left.split('.').map(Number);
+  const r = right.split('.').map(Number);
+
+  for (let i = 0; i < 3; i += 1) {
+    if (l[i] < r[i]) return -1;
+    if (l[i] > r[i]) return 1;
+  }
+
+  return 0;
+}
+
+module.exports = {
+  extractSemver,
+  compareVersions,
+};

package/package.json

@@ -1,35 +1,23 @@
 {
   "name": "agent-notify",
-  "version": "0.2.5",
-  "agentnotifyversion": "0.2.4",
-  "description": "Agent notification tool with Feishu integration",
+  "version": "0.3.0",
+  "description": "NPX launcher for the agent-notify binary",
   "bin": {
     "agent-notify": "./bin/agent-notify.js"
   },
-  "scripts": {
-    "postinstall": "node scripts/install.js"
-  },
+  "type": "commonjs",
   "files": [
-    "bin/",
-    "scripts/"
+    "bin",
+    "lib",
+    "test"
   ],
-  "keywords": [
-    "claude",
-    "notification",
-    "feishu",
-    "agent"
-  ],
-  "author": "hellolib",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/hellolib/agent-notify.git"
+  "scripts": {
+    "test": "node --test ./test/*.test.js"
   },
-  "bugs": {
-    "url": "https://github.com/hellolib/agent-notify/issues"
+  "dependencies": {
+    "tar": "^7.4.3"
   },
-  "homepage": "https://github.com/hellolib/agent-notify#readme",
   "engines": {
-    "node": ">=14"
+    "node": ">=18"
   }
 }

package/test/install.test.js

@@ -0,0 +1,152 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { PassThrough } = require('node:stream');
+const tar = require('tar');
+const { installFromArchive } = require('../lib/install');
+const { downloadToFile } = require('../lib/download');
+
+test('replaces installed binary with extracted binary', async (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-notify-install-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const installDir = path.join(root, '.agent-notify');
+  const archivePath = path.join(root, 'agent-notify-v0.2.3-linux-amd64.tar.gz');
+  const extractedBinaryName = 'agent-notify-v0.2.3-linux-amd64';
+
+  fs.mkdirSync(path.join(root, 'src'));
+  fs.writeFileSync(path.join(root, 'src', extractedBinaryName), 'new-binary');
+
+  await tar.c(
+    {
+      gzip: true,
+      file: archivePath,
+      cwd: path.join(root, 'src'),
+    },
+    [extractedBinaryName],
+  );
+
+  fs.mkdirSync(installDir, { recursive: true });
+  fs.writeFileSync(path.join(installDir, 'agent-notify'), 'old-binary');
+
+  const installedPath = await installFromArchive({
+    archivePath,
+    installDir,
+    binaryNameInArchive: extractedBinaryName,
+    finalBinaryName: 'agent-notify',
+  });
+
+  assert.equal(installedPath, path.join(installDir, 'agent-notify'));
+  assert.equal(fs.readFileSync(installedPath, 'utf8'), 'new-binary');
+});
+
+test('throws when archive does not contain expected binary', async (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-notify-install-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const installDir = path.join(root, '.agent-notify');
+  const archivePath = path.join(root, 'empty.tar.gz');
+
+  fs.mkdirSync(path.join(root, 'src'));
+  fs.writeFileSync(path.join(root, 'src', 'other-file'), 'nope');
+
+  await tar.c(
+    {
+      gzip: true,
+      file: archivePath,
+      cwd: path.join(root, 'src'),
+    },
+    ['other-file'],
+  );
+
+  await assert.rejects(
+    installFromArchive({
+      archivePath,
+      installDir,
+      binaryNameInArchive: 'agent-notify-v0.2.3-linux-amd64',
+      finalBinaryName: 'agent-notify',
+    }),
+    /binary not found in archive/,
+  );
+});
+
+test('follows relative redirects when downloading', async (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-notify-download-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const destinationPath = path.join(root, 'archive.tar.gz');
+
+  const client = {
+    get(url, options, handler) {
+      const request = new PassThrough();
+      process.nextTick(() => {
+        if (url === 'https://example.com/releases/archive.tar.gz') {
+          const response = new PassThrough();
+          response.statusCode = 302;
+          response.headers = { location: '/download/archive.tar.gz' };
+          handler(response);
+          response.end();
+          return;
+        }
+
+        const response = new PassThrough();
+        response.statusCode = 200;
+        response.headers = {};
+        handler(response);
+        response.end('payload');
+      });
+      return request;
+    },
+  };
+
+  const filePath = await downloadToFile('https://example.com/releases/archive.tar.gz', destinationPath, client);
+  assert.equal(filePath, destinationPath);
+  assert.equal(fs.readFileSync(destinationPath, 'utf8'), 'payload');
+});
+
+test('removes destination file when download fails with non-200 response', async (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-notify-download-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const destinationPath = path.join(root, 'archive.tar.gz');
+
+  const client = {
+    get(_url, _options, handler) {
+      const request = new PassThrough();
+      process.nextTick(() => {
+        const response = new PassThrough();
+        response.statusCode = 404;
+        response.headers = {};
+        handler(response);
+        response.end();
+      });
+      return request;
+    },
+  };
+
+  await assert.rejects(
+    downloadToFile('https://example.com/releases/archive.tar.gz', destinationPath, client),
+    /download failed: 404/,
+  );
+  assert.equal(fs.existsSync(destinationPath), false);
+});
+
+test('rejects with timeout error when download takes too long', async (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-notify-download-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const destinationPath = path.join(root, 'archive.tar.gz');
+
+  const client = {
+    get(_url, _options, handler) {
+      const request = new PassThrough();
+      process.nextTick(() => {
+        request.emit('timeout');
+      });
+      return request;
+    },
+  };
+
+  await assert.rejects(
+    downloadToFile('https://example.com/releases/archive.tar.gz', destinationPath, client),
+    /download timeout after 300s/,
+  );
+  assert.equal(fs.existsSync(destinationPath), false);
+});

package/test/launcher.test.js

@@ -0,0 +1,151 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { main } = require('../bin/agent-notify');
+
+test('downloads when installed binary is missing', async (t) => {
+  const calls = [];
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-notify-launcher-'));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const binaryPath = path.join(root, 'agent-notify');
+
+  const exitCode = await main(['doctor'], {
+    getDesiredVersion: () => '0.2.3',
+    getPlatformTarget: () => ({ goos: 'linux', goarch: 'amd64', ext: '' }),
+    getInstalledBinaryPath: () => binaryPath,
+    getInstalledVersion: () => null,
+    downloadAndInstall: async () => {
+      calls.push('download');
+      fs.writeFileSync(binaryPath, 'binary');
+      return binaryPath;
+    },
+    runBinary: async (targetPath, args) => {
+      calls.push(['run', targetPath, args]);
+      return 0;
+    },
+    pathExists: (value) => fs.existsSync(value),
+    warn: () => {},
+  });
+
+  assert.equal(exitCode, 0);
+  assert.deepEqual(calls, ['download', ['run', binaryPath, ['doctor']]]);
+});
+
+test('reuses installed binary when version is current', async () => {
+  const calls = [];
+
+  const exitCode = await main(['doctor'], {
+    getDesiredVersion: () => '0.2.3',
+    getPlatformTarget: () => ({ goos: 'linux', goarch: 'amd64', ext: '' }),
+    getInstalledBinaryPath: () => '/tmp/agent-notify',
+    getInstalledVersion: () => '0.2.3',
+    downloadAndInstall: async () => {
+      throw new Error('should not download');
+    },
+    runBinary: async (targetPath, args) => {
+      calls.push(['run', targetPath, args]);
+      return 0;
+    },
+    pathExists: () => true,
+    compareVersions: (left, right) => (left === right ? 0 : -1),
+    warn: () => {},
+  });
+
+  assert.equal(exitCode, 0);
+  assert.deepEqual(calls, [['run', '/tmp/agent-notify', ['doctor']]]);
+});
+
+test('reuses installed binary when local version is newer', async () => {
+  const calls = [];
+
+  const exitCode = await main(['doctor'], {
+    getDesiredVersion: () => '0.2.3',
+    getPlatformTarget: () => ({ goos: 'linux', goarch: 'amd64', ext: '' }),
+    getInstalledBinaryPath: () => '/tmp/agent-notify',
+    getInstalledVersion: () => '0.2.4',
+    downloadAndInstall: async () => {
+      throw new Error('should not download');
+    },
+    runBinary: async (targetPath, args) => {
+      calls.push(['run', targetPath, args]);
+      return 0;
+    },
+    pathExists: () => true,
+    compareVersions: () => 1,
+    warn: () => {},
+  });
+
+  assert.equal(exitCode, 0);
+  assert.deepEqual(calls, [['run', '/tmp/agent-notify', ['doctor']]]);
+});
+
+test('falls back to old binary when download fails but installed binary exists', async () => {
+  const warnings = [];
+  const calls = [];
+
+  const exitCode = await main(['doctor'], {
+    getDesiredVersion: () => '0.2.3',
+    getPlatformTarget: () => ({ goos: 'linux', goarch: 'amd64', ext: '' }),
+    getInstalledBinaryPath: () => '/tmp/agent-notify',
+    getInstalledVersion: () => '0.2.2',
+    compareVersions: () => -1,
+    downloadAndInstall: async () => {
+      throw new Error('network down');
+    },
+    runBinary: async (targetPath, args) => {
+      calls.push(['run', targetPath, args]);
+      return 0;
+    },
+    pathExists: () => true,
+    warn: (message) => warnings.push(message),
+  });
+
+  assert.equal(exitCode, 0);
+  assert.equal(warnings.length, 1);
+  assert.match(warnings[0], /network down/);
+  assert.deepEqual(calls, [['run', '/tmp/agent-notify', ['doctor']]]);
+});
+
+test('fails when download fails and no installed binary exists', async () => {
+  await assert.rejects(
+    main(['doctor'], {
+      getDesiredVersion: () => '0.2.3',
+      getPlatformTarget: () => ({ goos: 'linux', goarch: 'amd64', ext: '' }),
+      getInstalledBinaryPath: () => '/tmp/agent-notify',
+      getInstalledVersion: () => null,
+      compareVersions: () => -1,
+      downloadAndInstall: async () => {
+        throw new Error('network down');
+      },
+      runBinary: async () => 0,
+      pathExists: () => false,
+      warn: () => {},
+    }),
+    /network down/,
+  );
+});
+
+test('fails when installed binary is unreadable and update also fails', async () => {
+  const warnings = [];
+
+  await assert.rejects(
+    main(['doctor'], {
+      getDesiredVersion: () => '0.2.3',
+      getPlatformTarget: () => ({ goos: 'linux', goarch: 'amd64', ext: '' }),
+      getInstalledBinaryPath: () => '/tmp/agent-notify',
+      getInstalledVersion: () => null,
+      compareVersions: () => -1,
+      downloadAndInstall: async () => {
+        throw new Error('network down');
+      },
+      runBinary: async () => 0,
+      pathExists: () => true,
+      warn: (message) => warnings.push(message),
+    }),
+    /network down/,
+  );
+
+  assert.deepEqual(warnings, []);
+});

package/test/platform.test.js

@@ -0,0 +1,48 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { getPlatformTarget } = require('../lib/platform');
+const { buildAssetName, buildDownloadUrl } = require('../lib/release');
+
+test('maps darwin arm64 to release target', () => {
+  assert.deepEqual(getPlatformTarget({ platform: 'darwin', arch: 'arm64' }), {
+    goos: 'darwin',
+    goarch: 'arm64',
+    ext: '',
+  });
+});
+
+test('maps win32 x64 to release target', () => {
+  assert.deepEqual(getPlatformTarget({ platform: 'win32', arch: 'x64' }), {
+    goos: 'windows',
+    goarch: 'amd64',
+    ext: '.exe',
+  });
+});
+
+test('maps win32 arm64 to release target', () => {
+  assert.deepEqual(getPlatformTarget({ platform: 'win32', arch: 'arm64' }), {
+    goos: 'windows',
+    goarch: 'arm64',
+    ext: '.exe',
+  });
+});
+
+test('throws on unsupported platform', () => {
+  assert.throws(() => getPlatformTarget({ platform: 'freebsd', arch: 'x64' }), /unsupported platform/);
+});
+
+test('throws on unsupported architecture', () => {
+  assert.throws(() => getPlatformTarget({ platform: 'linux', arch: 'ia32' }), /unsupported platform/);
+});
+
+test('builds release asset names from version and target', () => {
+  const target = { goos: 'linux', goarch: 'arm64', ext: '' };
+  assert.equal(buildAssetName('0.2.3', target), 'agent-notify-v0.2.3-linux-arm64.tar.gz');
+});
+
+test('builds download URL from version and asset name', () => {
+  assert.equal(
+    buildDownloadUrl('0.2.3', 'agent-notify-v0.2.3-linux-arm64.tar.gz'),
+    'https://github.com/hellolib/agent-notify/releases/download/v0.2.3/agent-notify-v0.2.3-linux-arm64.tar.gz',
+  );
+});

package/test/version.test.js

@@ -0,0 +1,21 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const { extractSemver, compareVersions } = require('../lib/version');
+
+test('extracts plain semver', () => {
+  assert.equal(extractSemver('v0.2.3\n'), '0.2.3');
+});
+
+test('extracts semver from prefixed output', () => {
+  assert.equal(extractSemver('agent-notify version v1.4.0\n'), '1.4.0');
+});
+
+test('returns null when output has no semver', () => {
+  assert.equal(extractSemver('development build\n'), null);
+});
+
+test('compares versions correctly', () => {
+  assert.equal(compareVersions('0.2.3', '0.2.3'), 0);
+  assert.equal(compareVersions('0.2.2', '0.2.3'), -1);
+  assert.equal(compareVersions('0.3.0', '0.2.9'), 1);
+});

package/scripts/install.js

@@ -1,291 +0,0 @@
-#!/usr/bin/env node
-
-const https = require('https');
-const http = require('http');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { execSync } = require('child_process');
-
-const PACKAGE_VERSION = require('../package.json').agentnotifyversion;
-const GITHUB_REPO = 'hellolib/agent-notify';
-
-// Possible locations where agent-notify might be installed
-function getCommonBinaryDirs() {
-  const dirs = [];
-  const binaryName = os.platform() === 'win32' ? 'agent-notify.exe' : 'agent-notify';
-
-  // GOPATH/bin
-  if (process.env.GOPATH) {
-    dirs.push(path.join(process.env.GOPATH, 'bin'));
-  }
-  // GOBIN
-  if (process.env.GOBIN) {
-    dirs.push(process.env.GOBIN);
-  }
-  // Default Go bin directory
-  dirs.push(path.join(os.homedir(), 'go', 'bin'));
-  // ~/.local/bin
-  dirs.push(path.join(os.homedir(), '.local', 'bin'));
-  // /usr/local/bin
-  dirs.push('/usr/local/bin');
-
-  return dirs;
-}
-
-function findExistingBinary(binaryName) {
-  const dirs = getCommonBinaryDirs();
-  for (const dir of dirs) {
-    const binaryPath = path.join(dir, binaryName);
-    if (fs.existsSync(binaryPath)) {
-      return binaryPath;
-    }
-  }
-  return null;
-}
-
-function getBinaryDir() {
-  // Try to get npm global bin directory
-  // npm bin -g is deprecated, use npm prefix -g instead
-  try {
-    const prefix = execSync('npm prefix -g', { encoding: 'utf8' }).trim();
-    // On Windows, npm prefix -g returns the bin directory directly
-    // On Unix, it returns the parent and bin is in {prefix}/bin
-    if (os.platform() === 'win32') {
-      return prefix;
-    }
-    return path.join(prefix, 'bin');
-  } catch (e) {
-    // Fallback to ~/.local/bin
-    return path.join(os.homedir(), '.local', 'bin');
-  }
-}
-
-const BINARY_DIR = getBinaryDir();
-
-function getInstalledVersion(binaryPath) {
-  try {
-    const version = execSync(`"${binaryPath}" --version`, { encoding: 'utf8', timeout: 5000 }).trim();
-    // version output like: agent-notify version 0.1.0
-    const match = version.match(/(\d+\.\d+\.\d+)/);
-    return match ? match[1] : null;
-  } catch (e) {
-    return null;
-  }
-}
-
-function getRemoteArchiveName(version) {
-  const platform = os.platform();
-  const arch = os.arch();
-
-  const platformMap = {
-    darwin: 'darwin',
-    linux: 'linux',
-    win32: 'windows'
-  };
-
-  const archMap = {
-    x64: 'amd64',
-    arm64: 'arm64'
-  };
-
-  const mappedPlatform = platformMap[platform];
-  const mappedArch = archMap[arch];
-
-  if (!mappedPlatform || !mappedArch) {
-    throw new Error(`Unsupported platform: ${platform} ${arch}`);
-  }
-
-  return `agent-notify-v${version}-${mappedPlatform}-${mappedArch}.tar.gz`;
-}
-
-function getBinaryNameInArchive(version) {
-  const platform = os.platform();
-  const arch = os.arch();
-
-  const platformMap = {
-    darwin: 'darwin',
-    linux: 'linux',
-    win32: 'windows'
-  };
-
-  const archMap = {
-    x64: 'amd64',
-    arm64: 'arm64'
-  };
-
-  const mappedPlatform = platformMap[platform];
-  const mappedArch = archMap[arch];
-
-  if (platform === 'win32') {
-    return `agent-notify-v${version}-${mappedPlatform}-${mappedArch}.exe`;
-  }
-  return `agent-notify-v${version}-${mappedPlatform}-${mappedArch}`;
-}
-
-function getLocalBinaryName() {
-  return os.platform() === 'win32' ? 'agent-notify.exe' : 'agent-notify';
-}
-
-function getDownloadUrl(archiveName, version) {
-  return `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${archiveName}`;
-}
-
-function extractTarGz(archivePath, destDir) {
-  // Use tar command (available on macOS, Linux, and Windows 10+)
-  execSync(`tar -xzf "${archivePath}" -C "${destDir}"`, { stdio: 'inherit' });
-}
-
-async function install() {
-  const archiveName = getRemoteArchiveName(PACKAGE_VERSION);
-  const binaryNameInArchive = getBinaryNameInArchive(PACKAGE_VERSION);
-  const localBinaryName = getLocalBinaryName();
-  const binaryPath = path.join(BINARY_DIR, localBinaryName);
-
-  // Check if binary already exists in npm bin directory with correct version
-  if (fs.existsSync(binaryPath)) {
-    const installedVersion = getInstalledVersion(binaryPath);
-    if (installedVersion === PACKAGE_VERSION) {
-      console.log(`Binary already exists at ${binaryPath} (v${PACKAGE_VERSION})`);
-      return;
-    }
-    console.log(`Updating binary from v${installedVersion || 'unknown'} to v${PACKAGE_VERSION}...`);
-  } else {
-    // Check if binary exists in other common directories
-    const existingBinary = findExistingBinary(localBinaryName);
-    if (existingBinary) {
-      const existingVersion = getInstalledVersion(existingBinary);
-      if (existingVersion === PACKAGE_VERSION) {
-        // Same version, copy/link to npm bin directory
-        console.log(`Found existing binary at ${existingBinary} (v${PACKAGE_VERSION})`);
-        console.log(`Copying to npm bin directory: ${binaryPath}`);
-
-        if (!fs.existsSync(BINARY_DIR)) {
-          fs.mkdirSync(BINARY_DIR, { recursive: true });
-        }
-
-        fs.copyFileSync(existingBinary, binaryPath);
-        if (os.platform() !== 'win32') {
-          fs.chmodSync(binaryPath, 0o755);
-        }
-        console.log('Done!');
-        return;
-      } else if (existingVersion) {
-        console.log(`Found existing binary at ${existingBinary} (v${existingVersion}), but need v${PACKAGE_VERSION}`);
-        console.log('Installing new version to npm bin directory...');
-      } else {
-        console.log(`Found existing binary at ${existingBinary}, but version unknown`);
-        console.log('Installing to npm bin directory...');
-      }
-    }
-  }
-
-  // Create binary directory
-  if (!fs.existsSync(BINARY_DIR)) {
-    fs.mkdirSync(BINARY_DIR, { recursive: true });
-  }
-
-  const url = getDownloadUrl(archiveName, PACKAGE_VERSION);
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-notify-'));
-  const archivePath = path.join(tempDir, archiveName);
-
-  try {
-    // Download archive
-    await downloadFile(url, archivePath);
-
-    // Extract archive
-    console.log('Extracting...');
-    extractTarGz(archivePath, tempDir);
-
-    // Move binary to destination (use copy + unlink for cross-device support)
-    const extractedBinaryPath = path.join(tempDir, binaryNameInArchive);
-    if (fs.existsSync(binaryPath)) {
-      fs.unlinkSync(binaryPath);
-    }
-    fs.copyFileSync(extractedBinaryPath, binaryPath);
-    fs.unlinkSync(extractedBinaryPath);
-
-    // Make binary executable (Unix)
-    if (os.platform() !== 'win32') {
-      fs.chmodSync(binaryPath, 0o755);
-    }
-
-    console.log(`Successfully installed binary to ${binaryPath}`);
-    console.log(`Ensure ${BINARY_DIR} is in your PATH.`);
-  } catch (err) {
-    console.error(`Failed to download binary: ${err.message}`);
-    console.error('');
-    console.error('Please ensure the release exists at:');
-    console.error(`  ${url}`);
-
-    // Don't fail the install, let user download manually
-    process.exit(0);
-  } finally {
-    // Cleanup temp directory
-    try {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    } catch (e) {
-      // Ignore cleanup errors
-    }
-  }
-}
-
-function downloadFile(url, dest) {
-  return new Promise((resolve, reject) => {
-    const protocol = url.startsWith('https') ? https : http;
-
-    console.log(`Downloading: ${url}`);
-
-    const request = protocol.get(url, (response) => {
-      if (response.statusCode === 302 || response.statusCode === 301) {
-        downloadFile(response.headers.location, dest).then(resolve).catch(reject);
-        return;
-      }
-
-      if (response.statusCode !== 200) {
-        reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
-        return;
-      }
-
-      const totalSize = parseInt(response.headers['content-length'], 10);
-      let downloadedSize = 0;
-      let lastPercent = 0;
-
-      const file = fs.createWriteStream(dest);
-
-      response.on('data', (chunk) => {
-        downloadedSize += chunk.length;
-        if (totalSize) {
-          const percent = Math.floor((downloadedSize / totalSize) * 100);
-          if (percent >= lastPercent + 10) {
-            process.stdout.write(`\rDownloading: ${percent}%`);
-            lastPercent = percent;
-          }
-        }
-      });
-
-      response.pipe(file);
-
-      file.on('finish', () => {
-        file.close();
-        process.stdout.write('\n');
-        resolve();
-      });
-    });
-
-    request.on('error', (err) => {
-      fs.unlink(dest, () => {});
-      reject(err);
-    });
-
-    request.setTimeout(120000, () => {
-      request.destroy();
-      reject(new Error('Download timeout'));
-    });
-  });
-}
-
-install().catch((err) => {
-  console.error(err.message);
-  process.exit(1);
-});