@pajamadot/story-cli 0.1.0

package/bin/story.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+/**
+ * Thin shim that locates the platform-specific story binary
+ * (downloaded by postinstall.js) and spawns it with the user's args.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const ext = process.platform === 'win32' ? '.exe' : '';
+const binPath = path.join(__dirname, `story${ext}`);
+
+if (!fs.existsSync(binPath)) {
+  console.error(
+    `[story] Binary not found at ${binPath}\n\n` +
+    `This usually means the postinstall download failed.\n` +
+    `Try:\n` +
+    `  npm rebuild @pajamadot/story-cli\n` +
+    `  npm install -g @pajamadot/story-cli\n\n` +
+    `Or build from source:\n` +
+    `  cd story-cli && cargo build --release`
+  );
+  process.exit(1);
+}
+
+const child = spawn(binPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  windowsHide: false,
+});
+
+// Forward signals to the child process
+for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+  try {
+    process.on(sig, () => child.kill(sig));
+  } catch {
+    // SIGHUP may not exist on Windows
+  }
+}
+
+child.on('error', (err) => {
+  if (err.code === 'EACCES') {
+    console.error(
+      `[story] Permission denied running ${binPath}\n` +
+      `Try: chmod +x "${binPath}"`
+    );
+  } else {
+    console.error(`[story] Failed to run binary: ${err.message}`);
+  }
+  process.exit(1);
+});
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    // Re-raise the signal so the parent shell sees it
+    process.kill(process.pid, signal);
+  } else {
+    process.exit(code ?? 1);
+  }
+});

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@pajamadot/story-cli",
+  "version": "0.1.0",
+  "description": "CLI for PajamaDot Story Platform – create visual novels from the terminal",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pajamadot/story"
+  },
+  "bin": {
+    "story": "bin/story.js"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  },
+  "files": [
+    "bin/story.js",
+    "postinstall.js"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "keywords": [
+    "story",
+    "visual-novel",
+    "cli",
+    "pajamadot",
+    "narrative"
+  ]
+}

package/postinstall.js

@@ -0,0 +1,195 @@
+/**
+ * postinstall.js – downloads the platform-specific story binary
+ * from the PajamaDot CDN (R2) and places it in bin/.
+ *
+ * Layout on CDN (R2 bucket: pajamadot-releases):
+ *   <cdn>/cli/v0.1.0/story-x86_64-pc-windows-msvc.exe
+ *   <cdn>/cli/v0.1.0/story-aarch64-apple-darwin
+ *   <cdn>/cli/v0.1.0/checksums.sha256
+ *   <cdn>/cli/latest.json   → { "version": "0.1.0" }
+ */
+
+const https = require('https');
+const http = require('http');
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const pkg = require('./package.json');
+const VERSION = pkg.version;
+
+const CDN_BASE = process.env.STORY_CDN_URL || 'https://releases.pajamadot.com';
+
+const PLATFORM_MAP = {
+  'win32-x64': 'x86_64-pc-windows-msvc',
+  'linux-x64': 'x86_64-unknown-linux-gnu',
+  'linux-arm64': 'aarch64-unknown-linux-gnu',
+  'darwin-x64': 'x86_64-apple-darwin',
+  'darwin-arm64': 'aarch64-apple-darwin',
+};
+
+const MAX_RETRIES = 3;
+const RETRY_BASE_MS = 1000;
+
+function getPlatformKey() {
+  return `${process.platform}-${process.arch}`;
+}
+
+function getBinaryName() {
+  const ext = process.platform === 'win32' ? '.exe' : '';
+  return `story${ext}`;
+}
+
+function getTarget() {
+  const key = getPlatformKey();
+  const target = PLATFORM_MAP[key];
+  if (!target) {
+    throw new Error(
+      `Unsupported platform: ${key}\n` +
+      `Supported: ${Object.keys(PLATFORM_MAP).join(', ')}`
+    );
+  }
+  return target;
+}
+
+function getBinaryFilename() {
+  const ext = process.platform === 'win32' ? '.exe' : '';
+  return `story-${getTarget()}${ext}`;
+}
+
+function getDownloadUrl() {
+  return `${CDN_BASE}/cli/v${VERSION}/${getBinaryFilename()}`;
+}
+
+function getChecksumsUrl() {
+  return `${CDN_BASE}/cli/v${VERSION}/checksums.sha256`;
+}
+
+function fetchBuffer(url, redirectCount) {
+  if (redirectCount === undefined) redirectCount = 0;
+  return new Promise((resolve, reject) => {
+    if (redirectCount > 10) {
+      return reject(new Error('Too many redirects'));
+    }
+
+    const lib = url.startsWith('https') ? https : http;
+    const req = lib.get(url, { headers: { 'User-Agent': 'story-cli-postinstall' } }, (res) => {
+      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+        return resolve(fetchBuffer(res.headers.location, redirectCount + 1));
+      }
+
+      if (res.statusCode !== 200) {
+        // Consume body to free socket
+        res.resume();
+        return reject(new Error(`HTTP ${res.statusCode} from ${url}`));
+      }
+
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => resolve(Buffer.concat(chunks)));
+      res.on('error', reject);
+    });
+    req.on('error', reject);
+    req.setTimeout(60000, () => {
+      req.destroy(new Error('Request timed out'));
+    });
+  });
+}
+
+async function fetchWithRetry(url, label) {
+  let lastErr;
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await fetchBuffer(url);
+    } catch (err) {
+      lastErr = err;
+      if (attempt < MAX_RETRIES) {
+        const delay = RETRY_BASE_MS * Math.pow(2, attempt - 1);
+        console.log(`[story] ${label} attempt ${attempt} failed: ${err.message} — retrying in ${delay}ms`);
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastErr;
+}
+
+function sha256hex(buffer) {
+  return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+async function verifyChecksum(data, filename) {
+  try {
+    const checksumsBuffer = await fetchWithRetry(getChecksumsUrl(), 'checksums');
+    const checksums = checksumsBuffer.toString('utf8');
+    // Format: "<hex>  <filename>" per line (sha256sum output format)
+    for (const rawLine of checksums.split('\n')) {
+      const line = rawLine.replace(/\r$/, '');
+      const match = line.match(/^([a-f0-9]{64})\s+(.+)$/);
+      if (match && match[2].trim() === filename) {
+        const expected = match[1];
+        const actual = sha256hex(data);
+        if (actual !== expected) {
+          throw new Error(
+            `Checksum mismatch for ${filename}!\n` +
+            `  Expected: ${expected}\n` +
+            `  Got:      ${actual}`
+          );
+        }
+        console.log(`[story] Checksum verified: ${filename}`);
+        return;
+      }
+    }
+    // No matching entry — warn but don't fail
+    console.log(`[story] No checksum entry found for ${filename} — skipping verification`);
+  } catch (err) {
+    if (err.message.includes('Checksum mismatch')) {
+      throw err; // Always fail on mismatch
+    }
+    // Checksum file missing or unreachable — warn but continue
+    console.log(`[story] Could not verify checksum: ${err.message}`);
+  }
+}
+
+async function main() {
+  const binDir = path.join(__dirname, 'bin');
+  const binName = getBinaryName();
+  const destPath = path.join(binDir, binName);
+
+  // Skip if binary already exists (e.g. CI pre-built or manual placement)
+  if (fs.existsSync(destPath)) {
+    console.log(`[story] Binary already exists at ${destPath}`);
+    return;
+  }
+
+  const filename = getBinaryFilename();
+  const url = getDownloadUrl();
+  console.log(`[story] Downloading story CLI v${VERSION} for ${getPlatformKey()}`);
+  console.log(`[story] URL: ${url}`);
+
+  try {
+    const data = await fetchWithRetry(url, 'download');
+
+    // Verify SHA256 checksum
+    await verifyChecksum(data, filename);
+
+    fs.mkdirSync(binDir, { recursive: true });
+    fs.writeFileSync(destPath, data);
+
+    // Make executable on Unix
+    if (process.platform !== 'win32') {
+      fs.chmodSync(destPath, 0o755);
+    }
+
+    console.log(`[story] Installed story CLI v${VERSION} to ${destPath}`);
+  } catch (err) {
+    console.error(
+      `[story] Failed to download binary: ${err.message}\n\n` +
+      `You can manually download from:\n  ${url}\n` +
+      `and place it at:\n  ${destPath}\n\n` +
+      `Or build from source: cd story-cli && cargo build --release`
+    );
+    // Don't fail the install – the shim will report the missing binary at runtime
+  }
+}
+
+main();