@trackseries/cli 0.1.0-preview.1 → 0.1.0

package/README.md

@@ -17,7 +17,7 @@ Before the first stable release, install the current preview with:
 npm install --global @trackseries/cli@next
 ```
 
-The npm installer downloads and checksum-verifies the matching release artifact for the current operating system and architecture. The installed `trackseries` command is a standalone executable and does not use Node.js while running.
+The first `trackseries` invocation downloads and checksum-verifies the matching release artifact for the current operating system and architecture. Later invocations reuse the versioned executable from the platform-specific TrackSeries data directory. npm installation does not execute lifecycle scripts.
 
 Supported targets:
 
@@ -34,10 +34,10 @@ After installation, authenticate and inspect the available commands:
 ```bash
 trackseries auth login
 trackseries auth status
-trackseries skill
+trackseries --skill
 ```
 
-`trackseries skill` prints version-matched instructions designed for coding agents and other automated tools.
+`trackseries --skill` prints version-matched instructions designed for coding agents and other automated tools.
 
 ## Updates
 

package/bin/trackseries.js

@@ -2,15 +2,13 @@
 
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
+import { ensureBinary } from "../scripts/install.js";
 
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const executableName = process.platform === "win32" ? "trackseries.exe" : "trackseries";
-const executablePath = resolve(packageRoot, "vendor", executableName);
-
-if (!existsSync(executablePath)) {
-  console.error("The TrackSeries CLI executable is missing. Reinstall @trackseries/cli.");
+let executablePath;
+try {
+  executablePath = await ensureBinary();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
   process.exit(1);
 }
 
@@ -19,6 +17,10 @@ const result = spawnSync(executablePath, process.argv.slice(2), {
 });
 
 if (result.error) {
+  if (process.platform === "linux" && result.error.code === "ENOENT" && existsSync(executablePath)) {
+    console.error("Unable to start the TrackSeries CLI. NixOS and other non-FHS distributions may require nix-ld.");
+    process.exit(1);
+  }
   console.error(`Unable to start the TrackSeries CLI: ${result.error.message}`);
   process.exit(1);
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@trackseries/cli",
-  "version": "0.1.0-preview.1",
+  "version": "0.1.0",
   "description": "Install and run the TrackSeries CLI.",
   "type": "module",
   "bin": {
-    "trackseries": "./bin/trackseries.js"
+    "trackseries": "bin/trackseries.js"
   },
   "files": [
     "bin/trackseries.js",
@@ -12,7 +12,6 @@
     "scripts/platform.js"
   ],
   "scripts": {
-    "postinstall": "node scripts/install.js",
     "test": "node --test"
   },
   "engines": {

package/scripts/install.js

@@ -5,22 +5,12 @@ import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { unzipSync } from "fflate";
 import { x as extractTar } from "tar";
-import { assertSupportedRuntime, releaseArtifact } from "./platform.js";
+import { assertSupportedRuntime, binaryDirectory, releaseArtifact } from "./platform.js";
 
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const metadata = JSON.parse(await readFile(resolve(packageRoot, "package.json"), "utf8"));
-assertSupportedRuntime();
-const artifact = releaseArtifact(metadata.version);
-const releaseBaseUrl =
-  process.env.TRACKSERIES_CLI_RELEASE_BASE_URL ?? `https://github.com/TrackSeries/cli/releases/download/cli-v${metadata.version}`;
-const temporaryDirectory = await mkdtemp(resolve(tmpdir(), "trackseries-cli-"));
-const archivePath = resolve(temporaryDirectory, artifact);
-const extractionPath = resolve(temporaryDirectory, "extracted");
-const executableName = process.platform === "win32" ? "trackseries.exe" : "trackseries";
-const installedExecutable = resolve(packageRoot, "vendor", executableName);
-const pendingExecutable = `${installedExecutable}.${process.pid}.tmp`;
-
-async function download(url) {
+
+async function download(url, timeout) {
   let lastError;
 
   for (let attempt = 1; attempt <= 3; attempt += 1) {
@@ -30,7 +20,7 @@ async function download(url) {
         headers: {
           "User-Agent": `@trackseries/cli/${metadata.version}`
         },
-        signal: AbortSignal.timeout(60_000)
+        signal: AbortSignal.timeout(timeout)
       });
     } catch (error) {
       lastError = error;
@@ -53,58 +43,87 @@ async function download(url) {
   throw new Error(`Unable to download ${url}: ${lastError instanceof Error ? lastError.message : String(lastError)}.`);
 }
 
-try {
-  const [archive, checksumFile] = await Promise.all([
-    download(`${releaseBaseUrl}/${artifact}`),
-    download(`${releaseBaseUrl}/${artifact}.sha256`)
-  ]);
-  const expectedChecksum = checksumFile.toString("utf8").trim().split(/\s+/)[0]?.toLowerCase();
-  const actualChecksum = createHash("sha256").update(archive).digest("hex");
-
-  if (!expectedChecksum || actualChecksum !== expectedChecksum) {
-    throw new Error(`Checksum verification failed for ${artifact}.`);
+async function isRegularFile(path) {
+  try {
+    return (await lstat(path)).isFile();
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return false;
+    throw error;
   }
+}
+
+export async function ensureBinary() {
+  assertSupportedRuntime();
+  const artifact = releaseArtifact(metadata.version);
+  const releaseBaseUrl =
+    process.env.TRACKSERIES_CLI_RELEASE_BASE_URL ?? `https://github.com/TrackSeries/cli/releases/download/cli-v${metadata.version}`;
+  const executableName = process.platform === "win32" ? "trackseries.exe" : "trackseries";
+  const installedExecutable = resolve(binaryDirectory(metadata.version), executableName);
+
+  if (await isRegularFile(installedExecutable)) return installedExecutable;
 
-  await mkdir(extractionPath, { recursive: true });
-  await writeFile(archivePath, archive);
+  const temporaryDirectory = await mkdtemp(resolve(tmpdir(), "trackseries-cli-"));
+  const archivePath = resolve(temporaryDirectory, artifact);
+  const extractionPath = resolve(temporaryDirectory, "extracted");
+  const pendingExecutable = `${installedExecutable}.${process.pid}.tmp`;
 
-  if (process.platform === "win32") {
-    const executable = unzipSync(archive, {
-      filter: (file) => file.name === executableName
-    })[executableName];
-    if (!executable) {
-      throw new Error(`${artifact} does not contain ${executableName}.`);
+  console.error(`Downloading TrackSeries CLI ${metadata.version} for ${process.platform}-${process.arch}...`);
+
+  try {
+    const [archive, checksumFile] = await Promise.all([
+      download(`${releaseBaseUrl}/${artifact}`, 300_000),
+      download(`${releaseBaseUrl}/${artifact}.sha256`, 60_000)
+    ]);
+    const expectedChecksum = checksumFile.toString("utf8").trim().split(/\s+/)[0]?.toLowerCase();
+    const actualChecksum = createHash("sha256").update(archive).digest("hex");
+
+    if (!expectedChecksum || actualChecksum !== expectedChecksum) {
+      throw new Error(`Checksum verification failed for ${artifact}.`);
     }
-    await writeFile(resolve(extractionPath, executableName), executable);
-  } else {
-    await extractTar({
-      cwd: extractionPath,
-      file: archivePath,
-      filter: (path, entry) => (path === executableName || path === `./${executableName}`) && entry.type === "File"
-    });
-  }
 
-  const extractedExecutable = resolve(extractionPath, executableName);
-  if (!(await lstat(extractedExecutable)).isFile()) {
-    throw new Error(`${artifact} does not contain a regular ${executableName} file.`);
-  }
+    await mkdir(extractionPath, { recursive: true });
+    await writeFile(archivePath, archive);
 
-  await mkdir(dirname(installedExecutable), { recursive: true });
-  await copyFile(extractedExecutable, pendingExecutable);
+    if (process.platform === "win32") {
+      const executable = unzipSync(archive, {
+        filter: (file) => file.name === executableName
+      })[executableName];
+      if (!executable) {
+        throw new Error(`${artifact} does not contain ${executableName}.`);
+      }
+      await writeFile(resolve(extractionPath, executableName), executable);
+    } else {
+      await extractTar({
+        cwd: extractionPath,
+        file: archivePath,
+        filter: (path, entry) => (path === executableName || path === `./${executableName}`) && entry.type === "File"
+      });
+    }
 
-  if (process.platform !== "win32") {
-    await chmod(pendingExecutable, 0o755);
-  } else {
-    await rm(installedExecutable, { force: true });
-  }
+    const extractedExecutable = resolve(extractionPath, executableName);
+    if (!(await lstat(extractedExecutable)).isFile()) {
+      throw new Error(`${artifact} does not contain a regular ${executableName} file.`);
+    }
 
-  await rename(pendingExecutable, installedExecutable);
-} catch (error) {
-  throw new Error(
-    `Unable to install TrackSeries CLI ${metadata.version}. Download ${artifact} manually from ${releaseBaseUrl}.`,
-    { cause: error }
-  );
-} finally {
-  await rm(pendingExecutable, { force: true });
-  await rm(temporaryDirectory, { force: true, recursive: true });
+    await mkdir(dirname(installedExecutable), { recursive: true });
+    await copyFile(extractedExecutable, pendingExecutable);
+
+    if (process.platform !== "win32") {
+      await chmod(pendingExecutable, 0o755);
+    } else {
+      await rm(installedExecutable, { force: true });
+    }
+
+    await rename(pendingExecutable, installedExecutable);
+    return installedExecutable;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Unable to install TrackSeries CLI ${metadata.version}: ${reason} Download ${artifact} manually from ${releaseBaseUrl}.`,
+      { cause: error }
+    );
+  } finally {
+    await rm(pendingExecutable, { force: true });
+    await rm(temporaryDirectory, { force: true, recursive: true });
+  }
 }

package/scripts/platform.js

@@ -1,3 +1,6 @@
+import { homedir } from "node:os";
+import { posix, win32 } from "node:path";
+
 export function releaseArtifact(version, platform = process.platform, architecture = process.arch) {
   const platformNames = {
     darwin: "macos",
@@ -20,3 +23,18 @@ export function assertSupportedRuntime(platform = process.platform, report = pro
     throw new Error("TrackSeries CLI requires a glibc-based Linux distribution. Alpine and other musl-based systems are not yet supported.");
   }
 }
+
+export function binaryDirectory(version, platform = process.platform, environment = process.env, home = homedir()) {
+  const path = platform === "win32" ? win32 : posix;
+  let dataDirectory;
+
+  if (platform === "win32") {
+    dataDirectory = environment.LOCALAPPDATA ?? environment.APPDATA ?? path.join(home, "AppData", "Local");
+  } else if (platform === "darwin") {
+    dataDirectory = path.join(home, "Library", "Application Support");
+  } else {
+    dataDirectory = environment.XDG_DATA_HOME ?? path.join(home, ".local", "share");
+  }
+
+  return path.join(dataDirectory, "trackseries", "bin", version);
+}