@oaftobark/spoq 0.1.2

package/bin.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+const { spawn } = require("child_process");
+const path = require("path");
+
+const PLATFORMS = {
+  "darwin-arm64": "@oaftobark/spoq-darwin-arm64",
+  "darwin-x64": "@oaftobark/spoq-darwin-x64",
+  "linux-arm64": "@oaftobark/spoq-linux-arm64",
+  "linux-x64": "@oaftobark/spoq-linux-x64",
+  "win32-x64": "@oaftobark/spoq-win32-x64",
+};
+
+function getBinaryPath() {
+  const platformKey = `${process.platform}-${process.arch}`;
+  const packageName = PLATFORMS[platformKey];
+
+  if (!packageName) {
+    console.error(`Unsupported platform: ${platformKey}`);
+    console.error(`Supported platforms: ${Object.keys(PLATFORMS).join(", ")}`);
+    process.exit(1);
+  }
+
+  const binaryName = process.platform === "win32" ? "spoq.exe" : "spoq";
+
+  try {
+    const packagePath = require.resolve(`${packageName}/package.json`);
+    const packageDir = path.dirname(packagePath);
+    return path.join(packageDir, "bin", binaryName);
+  } catch (e) {
+    // Package not found, check for local binary (fallback from postinstall)
+    const localBinary = path.join(__dirname, "bin", binaryName);
+    try {
+      require("fs").accessSync(localBinary, require("fs").constants.X_OK);
+      return localBinary;
+    } catch {
+      console.error(`Could not find spoq binary for ${platformKey}`);
+      console.error(
+        "Please try reinstalling: npm install -g @oaftobark/spoq"
+      );
+      process.exit(1);
+    }
+  }
+}
+
+const binaryPath = getBinaryPath();
+const args = process.argv.slice(2);
+
+const child = spawn(binaryPath, args, {
+  stdio: "inherit",
+  env: process.env,
+});
+
+child.on("error", (err) => {
+  console.error(`Failed to start spoq: ${err.message}`);
+  process.exit(1);
+});
+
+child.on("close", (code) => {
+  process.exit(code ?? 0);
+});

package/bin.test.js

@@ -0,0 +1,75 @@
+const assert = require("assert");
+const path = require("path");
+
+console.log("Running bin.js tests...\n");
+
+// Test platform mapping
+{
+  console.log("Test: Platform mappings");
+  const PLATFORMS = {
+    "darwin-arm64": "@oaftobark/spoq-darwin-arm64",
+    "darwin-x64": "@oaftobark/spoq-darwin-x64",
+    "linux-arm64": "@oaftobark/spoq-linux-arm64",
+    "linux-x64": "@oaftobark/spoq-linux-x64",
+    "win32-x64": "@oaftobark/spoq-win32-x64",
+  };
+
+  assert.strictEqual(PLATFORMS["darwin-arm64"], "@oaftobark/spoq-darwin-arm64");
+  assert.strictEqual(PLATFORMS["darwin-x64"], "@oaftobark/spoq-darwin-x64");
+  assert.strictEqual(PLATFORMS["linux-arm64"], "@oaftobark/spoq-linux-arm64");
+  assert.strictEqual(PLATFORMS["linux-x64"], "@oaftobark/spoq-linux-x64");
+  assert.strictEqual(PLATFORMS["win32-x64"], "@oaftobark/spoq-win32-x64");
+  console.log("  PASS: All platform mappings correct\n");
+}
+
+{
+  console.log("Test: Binary name for Unix platforms");
+  const binaryName = "darwin" === "win32" ? "spoq.exe" : "spoq";
+  assert.strictEqual(binaryName, "spoq");
+  console.log("  PASS: Unix binary name is 'spoq'\n");
+}
+
+{
+  console.log("Test: Binary name for Windows platform");
+  const binaryName = "win32" === "win32" ? "spoq.exe" : "spoq";
+  assert.strictEqual(binaryName, "spoq.exe");
+  console.log("  PASS: Windows binary name is 'spoq.exe'\n");
+}
+
+{
+  console.log("Test: Package path construction");
+  const packageName = "@oaftobark/spoq-darwin-arm64";
+  const packagePath = `${packageName}/package.json`;
+  assert.strictEqual(packagePath, "@oaftobark/spoq-darwin-arm64/package.json");
+  console.log("  PASS: Package path constructed correctly\n");
+}
+
+{
+  console.log("Test: Supported platform key format");
+  const platformKey = `darwin-arm64`;
+  assert.ok(/^(darwin|linux|win32)-(arm64|x64)$/.test(platformKey));
+  console.log("  PASS: Platform key format validated\n");
+}
+
+{
+  console.log("Test: Unsupported platform detection");
+  const platformKey = `freebsd-x64`;
+  const PLATFORMS = {
+    "darwin-arm64": "@oaftobark/spoq-darwin-arm64",
+    "darwin-x64": "@oaftobark/spoq-darwin-x64",
+    "linux-arm64": "@oaftobark/spoq-linux-arm64",
+    "linux-x64": "@oaftobark/spoq-linux-x64",
+    "win32-x64": "@oaftobark/spoq-win32-x64",
+  };
+  assert.strictEqual(PLATFORMS[platformKey], undefined);
+  console.log("  PASS: Unsupported platform returns undefined\n");
+}
+
+{
+  console.log("Test: Local binary path construction");
+  const localBinary = path.join("/test/dir", "bin", "spoq");
+  assert.strictEqual(localBinary, "/test/dir/bin/spoq");
+  console.log("  PASS: Local binary path constructed correctly\n");
+}
+
+console.log("All bin.js tests passed!");

package/install.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+/**
+ * Postinstall script for @oaftobark/spoq
+ *
+ * This script handles the fallback case when the optional platform-specific
+ * dependency fails to install (e.g., on unsupported platforms or when npm
+ * can't resolve the optional dependency).
+ *
+ * It downloads the appropriate binary from GitHub releases.
+ */
+
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const PACKAGE_VERSION = require("./package.json").version;
+const GITHUB_REPO = "oaftobark/spoq";
+
+const PLATFORMS = {
+  "darwin-arm64": "spoq-darwin-arm64.tar.gz",
+  "darwin-x64": "spoq-darwin-x64.tar.gz",
+  "linux-arm64": "spoq-linux-arm64.tar.gz",
+  "linux-x64": "spoq-linux-x64.tar.gz",
+  "win32-x64": "spoq-win32-x64.zip",
+};
+
+function getPlatformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+
+function isPlatformPackageInstalled() {
+  const platformKey = getPlatformKey();
+  const packageNames = {
+    "darwin-arm64": "@oaftobark/spoq-darwin-arm64",
+    "darwin-x64": "@oaftobark/spoq-darwin-x64",
+    "linux-arm64": "@oaftobark/spoq-linux-arm64",
+    "linux-x64": "@oaftobark/spoq-linux-x64",
+    "win32-x64": "@oaftobark/spoq-win32-x64",
+  };
+
+  const packageName = packageNames[platformKey];
+  if (!packageName) return false;
+
+  try {
+    require.resolve(`${packageName}/package.json`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function downloadFile(url) {
+  return new Promise((resolve, reject) => {
+    const request = (url) => {
+      https
+        .get(url, (response) => {
+          if (response.statusCode === 302 || response.statusCode === 301) {
+            request(response.headers.location);
+            return;
+          }
+
+          if (response.statusCode !== 200) {
+            reject(new Error(`HTTP ${response.statusCode}: ${url}`));
+            return;
+          }
+
+          const chunks = [];
+          response.on("data", (chunk) => chunks.push(chunk));
+          response.on("end", () => resolve(Buffer.concat(chunks)));
+          response.on("error", reject);
+        })
+        .on("error", reject);
+    };
+    request(url);
+  });
+}
+
+async function extractTarGz(buffer, destDir) {
+  const tempFile = path.join(destDir, "temp.tar.gz");
+  fs.writeFileSync(tempFile, buffer);
+  try {
+    execSync(`tar -xzf "${tempFile}" -C "${destDir}"`, { stdio: "pipe" });
+  } finally {
+    fs.unlinkSync(tempFile);
+  }
+}
+
+async function extractZip(buffer, destDir) {
+  const tempFile = path.join(destDir, "temp.zip");
+  fs.writeFileSync(tempFile, buffer);
+  try {
+    execSync(`unzip -o "${tempFile}" -d "${destDir}"`, { stdio: "pipe" });
+  } finally {
+    fs.unlinkSync(tempFile);
+  }
+}
+
+async function main() {
+  // Skip if platform package is already installed
+  if (isPlatformPackageInstalled()) {
+    return;
+  }
+
+  const platformKey = getPlatformKey();
+  const archiveFile = PLATFORMS[platformKey];
+
+  if (!archiveFile) {
+    console.warn(`Warning: No prebuilt binary available for ${platformKey}`);
+    console.warn("You may need to build spoq from source.");
+    return;
+  }
+
+  console.log(`Platform package not found, downloading binary for ${platformKey}...`);
+
+  const binDir = path.join(__dirname, "bin");
+  fs.mkdirSync(binDir, { recursive: true });
+
+  const downloadUrl = `https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/${archiveFile}`;
+
+  try {
+    const buffer = await downloadFile(downloadUrl);
+
+    if (archiveFile.endsWith(".tar.gz")) {
+      await extractTarGz(buffer, binDir);
+    } else if (archiveFile.endsWith(".zip")) {
+      await extractZip(buffer, binDir);
+    }
+
+    // Make binary executable on Unix
+    if (process.platform !== "win32") {
+      const binaryPath = path.join(binDir, "spoq");
+      fs.chmodSync(binaryPath, 0o755);
+    }
+
+    console.log("Binary downloaded successfully.");
+  } catch (err) {
+    console.warn(`Warning: Failed to download binary: ${err.message}`);
+    console.warn("You may need to build spoq from source or install manually.");
+  }
+}
+
+main().catch((err) => {
+  console.warn(`Postinstall warning: ${err.message}`);
+});

package/install.test.js

@@ -0,0 +1,148 @@
+const assert = require("assert");
+
+console.log("Running install.js tests...\n");
+
+// Platform Detection Tests
+{
+  console.log("Test: Archive names for all platforms");
+  const PLATFORMS = {
+    "darwin-arm64": "spoq-darwin-arm64.tar.gz",
+    "darwin-x64": "spoq-darwin-x64.tar.gz",
+    "linux-arm64": "spoq-linux-arm64.tar.gz",
+    "linux-x64": "spoq-linux-x64.tar.gz",
+    "win32-x64": "spoq-win32-x64.zip",
+  };
+
+  assert.strictEqual(PLATFORMS["darwin-arm64"], "spoq-darwin-arm64.tar.gz");
+  assert.strictEqual(PLATFORMS["darwin-x64"], "spoq-darwin-x64.tar.gz");
+  assert.strictEqual(PLATFORMS["linux-arm64"], "spoq-linux-arm64.tar.gz");
+  assert.strictEqual(PLATFORMS["linux-x64"], "spoq-linux-x64.tar.gz");
+  assert.strictEqual(PLATFORMS["win32-x64"], "spoq-win32-x64.zip");
+  console.log("  PASS: All archive names correct\n");
+}
+
+{
+  console.log("Test: Unix platforms use tar.gz");
+  const PLATFORMS = {
+    "darwin-arm64": "spoq-darwin-arm64.tar.gz",
+    "darwin-x64": "spoq-darwin-x64.tar.gz",
+    "linux-arm64": "spoq-linux-arm64.tar.gz",
+    "linux-x64": "spoq-linux-x64.tar.gz",
+  };
+
+  assert.ok(PLATFORMS["darwin-arm64"].endsWith(".tar.gz"));
+  assert.ok(PLATFORMS["darwin-x64"].endsWith(".tar.gz"));
+  assert.ok(PLATFORMS["linux-arm64"].endsWith(".tar.gz"));
+  assert.ok(PLATFORMS["linux-x64"].endsWith(".tar.gz"));
+  console.log("  PASS: Unix platforms use tar.gz format\n");
+}
+
+{
+  console.log("Test: Windows platform uses zip");
+  const archive = "spoq-win32-x64.zip";
+  assert.ok(archive.endsWith(".zip"));
+  console.log("  PASS: Windows platform uses zip format\n");
+}
+
+{
+  console.log("Test: Platform key construction");
+  const platformKey = `${process.platform}-${process.arch}`;
+  assert.ok(typeof platformKey === "string");
+  assert.ok(platformKey.includes("-"));
+  console.log("  PASS: Platform key constructed correctly\n");
+}
+
+// Download URL Construction Tests
+{
+  console.log("Test: GitHub release URL construction");
+  const PACKAGE_VERSION = "0.1.0";
+  const GITHUB_REPO = "oaftobark/spoq";
+  const archiveFile = "spoq-darwin-arm64.tar.gz";
+  const url = `https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/${archiveFile}`;
+  assert.strictEqual(url, "https://github.com/oaftobark/spoq/releases/download/v0.1.0/spoq-darwin-arm64.tar.gz");
+  console.log("  PASS: GitHub URL constructed correctly\n");
+}
+
+{
+  console.log("Test: Version prefix in URL");
+  const PACKAGE_VERSION = "0.1.0";
+  const GITHUB_REPO = "oaftobark/spoq";
+  const url = `https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/spoq-linux-x64.tar.gz`;
+  assert.ok(url.includes("/v0.1.0/"));
+  console.log("  PASS: Version prefix included in URL\n");
+}
+
+{
+  console.log("Test: URLs for all platforms");
+  const PACKAGE_VERSION = "0.1.0";
+  const GITHUB_REPO = "oaftobark/spoq";
+  const platforms = ["darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64", "win32-x64"];
+
+  platforms.forEach(platform => {
+    const archiveExt = platform.startsWith("win32") ? "zip" : "tar.gz";
+    const url = `https://github.com/${GITHUB_REPO}/releases/download/v${PACKAGE_VERSION}/spoq-${platform}.${archiveExt}`;
+    assert.ok(url.startsWith("https://github.com/"));
+    assert.ok(url.includes(platform));
+  });
+  console.log("  PASS: URLs for all platforms valid\n");
+}
+
+// Package Resolution Tests
+{
+  console.log("Test: Package name mappings");
+  const packageNames = {
+    "darwin-arm64": "@oaftobark/spoq-darwin-arm64",
+    "darwin-x64": "@oaftobark/spoq-darwin-x64",
+    "linux-arm64": "@oaftobark/spoq-linux-arm64",
+    "linux-x64": "@oaftobark/spoq-linux-x64",
+    "win32-x64": "@oaftobark/spoq-win32-x64",
+  };
+
+  assert.strictEqual(packageNames["darwin-arm64"], "@oaftobark/spoq-darwin-arm64");
+  assert.strictEqual(packageNames["linux-x64"], "@oaftobark/spoq-linux-x64");
+  assert.strictEqual(packageNames["win32-x64"], "@oaftobark/spoq-win32-x64");
+  console.log("  PASS: Package names mapped correctly\n");
+}
+
+{
+  console.log("Test: Unsupported platform returns undefined");
+  const platformKey = "freebsd-x64";
+  const packageNames = {
+    "darwin-arm64": "@oaftobark/spoq-darwin-arm64",
+    "darwin-x64": "@oaftobark/spoq-darwin-x64",
+    "linux-arm64": "@oaftobark/spoq-linux-arm64",
+    "linux-x64": "@oaftobark/spoq-linux-x64",
+    "win32-x64": "@oaftobark/spoq-win32-x64",
+  };
+  const packageName = packageNames[platformKey];
+  assert.strictEqual(packageName, undefined);
+  console.log("  PASS: Unsupported platform returns undefined\n");
+}
+
+// HTTP Response Handling Tests
+{
+  console.log("Test: Redirect status codes");
+  const redirectCodes = [301, 302];
+  redirectCodes.forEach(code => {
+    assert.ok(code === 301 || code === 302);
+  });
+  console.log("  PASS: Redirect status codes handled\n");
+}
+
+{
+  console.log("Test: Success status code");
+  const statusCode = 200;
+  assert.strictEqual(statusCode, 200);
+  console.log("  PASS: Success status code is 200\n");
+}
+
+{
+  console.log("Test: Error status codes detection");
+  const errorCodes = [404, 500, 403];
+  errorCodes.forEach(code => {
+    assert.ok(code !== 200);
+  });
+  console.log("  PASS: Error status codes detected\n");
+}
+
+console.log("All install.js tests passed!");

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@oaftobark/spoq",
+  "version": "0.1.2",
+  "description": "A terminal-based Spotify client",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oaftobark/spoq.git"
+  },
+  "license": "MIT",
+  "bin": {
+    "spoq": "bin.js"
+  },
+  "scripts": {
+    "postinstall": "node install.js"
+  },
+  "optionalDependencies": {
+    "@oaftobark/spoq-darwin-arm64": "0.1.2",
+    "@oaftobark/spoq-darwin-x64": "0.1.2",
+    "@oaftobark/spoq-linux-arm64": "0.1.2",
+    "@oaftobark/spoq-linux-x64": "0.1.2",
+    "@oaftobark/spoq-win32-x64": "0.1.2"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "keywords": [
+    "spotify",
+    "terminal",
+    "tui",
+    "music",
+    "cli"
+  ]
+}