quilltap 3.0.0-dev.79

package/README.md

@@ -0,0 +1,109 @@
+# Quilltap
+
+**Self-hosted AI workspace for writers, worldbuilders, roleplayers, and anyone who wants an AI assistant that actually knows what they're working on.**
+
+Run Quilltap as a local Node.js server with zero configuration.
+
+## Quick Start
+
+```bash
+npm install -g quilltap
+quilltap
+```
+
+Then open [http://localhost:3000](http://localhost:3000).
+
+On first run, the CLI downloads the application files (~150-250 MB compressed) and caches them locally. Subsequent launches start instantly.
+
+## Installation
+
+### Install globally (recommended)
+
+```bash
+npm install -g quilltap
+quilltap
+```
+
+### Run directly (no install)
+
+```bash
+npx quilltap
+```
+
+## Usage
+
+```
+quilltap [options]
+
+Options:
+  -p, --port <number>     Port to listen on (default: 3000)
+  -d, --data-dir <path>   Data directory (default: platform-specific)
+  -o, --open              Open browser after server starts
+  -v, --version           Show version number
+  --update                Force re-download of application files
+  -h, --help              Show this help message
+```
+
+### Examples
+
+```bash
+# Start on default port 3000
+quilltap
+
+# Start on a custom port
+quilltap --port 8080
+
+# Use a custom data directory
+quilltap --data-dir /mnt/data/quilltap
+
+# Start and open browser automatically
+quilltap --open
+
+# Force re-download after a manual update
+quilltap --update
+```
+
+## How It Works
+
+The `quilltap` npm package is a lightweight CLI launcher (~10 KB). On first run, it downloads the pre-built application from [GitHub Releases](https://github.com/foundry-9/quilltap/releases) and caches it in a platform-specific directory. Native modules (`better-sqlite3`, `sharp`) are compiled for your platform when you install the npm package.
+
+### Cache Locations
+
+| Platform | Cache Directory |
+| --- | --- |
+| macOS | `~/Library/Caches/Quilltap/standalone/` |
+| Linux | `~/.cache/quilltap/standalone/` |
+| Windows | `%LOCALAPPDATA%\Quilltap\standalone\` |
+
+When you upgrade to a new version (`npm update -g quilltap`), the next run detects the version mismatch and downloads the matching application files automatically.
+
+## Data Directory
+
+Quilltap stores its database, files, and logs in a platform-specific directory:
+
+| Platform | Default Location |
+| --- | --- |
+| macOS | `~/Library/Application Support/Quilltap` |
+| Linux | `~/.quilltap` |
+| Windows | `%APPDATA%\Quilltap` |
+
+Override with `--data-dir` or the `QUILLTAP_DATA_DIR` environment variable.
+
+## Requirements
+
+- Node.js 18 or later
+
+## Other Ways to Run Quilltap
+
+- **Electron desktop app** (macOS, Windows) - [Download](https://github.com/foundry-9/quilltap/releases)
+- **Docker** - `docker run -d -p 3000:3000 -v /path/to/data:/app/quilltap csebold/quilltap`
+
+## Links
+
+- **Website:** [quilltap.ai](https://quilltap.ai)
+- **GitHub:** [github.com/foundry-9/quilltap](https://github.com/foundry-9/quilltap)
+- **Issues:** [github.com/foundry-9/quilltap/issues](https://github.com/foundry-9/quilltap/issues)
+
+## License
+
+MIT

package/bin/quilltap.js

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+'use strict';
+
+const { fork, exec } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { getCacheDir, isCacheValid, ensureStandalone } = require('../lib/download-manager');
+
+const PACKAGE_DIR = path.resolve(__dirname, '..');
+
+// Read version from package.json
+function getVersion() {
+  const pkg = JSON.parse(fs.readFileSync(path.join(PACKAGE_DIR, 'package.json'), 'utf-8'));
+  return pkg.version;
+}
+
+// Parse CLI arguments
+function parseArgs(argv) {
+  const opts = {
+    port: 3000,
+    dataDir: '',
+    open: false,
+    help: false,
+    version: false,
+    update: false,
+  };
+
+  const args = argv.slice(2);
+  let i = 0;
+  while (i < args.length) {
+    switch (args[i]) {
+      case '--port':
+      case '-p':
+        opts.port = parseInt(args[++i], 10);
+        if (isNaN(opts.port) || opts.port < 1 || opts.port > 65535) {
+          console.error('Error: --port must be a number between 1 and 65535');
+          process.exit(1);
+        }
+        break;
+      case '--data-dir':
+      case '-d':
+        opts.dataDir = args[++i];
+        break;
+      case '--open':
+      case '-o':
+        opts.open = true;
+        break;
+      case '--version':
+      case '-v':
+        opts.version = true;
+        break;
+      case '--update':
+        opts.update = true;
+        break;
+      case '--help':
+      case '-h':
+        opts.help = true;
+        break;
+      default:
+        console.error(`Unknown argument: ${args[i]}`);
+        console.error('Run "quilltap --help" for usage information.');
+        process.exit(1);
+    }
+    i++;
+  }
+
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+Quilltap - Self-hosted AI workspace
+
+Usage: quilltap [options]
+
+Options:
+  -p, --port <number>     Port to listen on (default: 3000)
+  -d, --data-dir <path>   Data directory (default: platform-specific)
+  -o, --open              Open browser after server starts
+  -v, --version           Show version number
+  --update                Force re-download of application files
+  -h, --help              Show this help message
+
+Data directory defaults:
+  macOS:    ~/Library/Application Support/Quilltap
+  Linux:    ~/.quilltap
+  Windows:  %APPDATA%\\Quilltap
+
+Examples:
+  quilltap                              # Start on port 3000
+  quilltap -p 8080                      # Start on port 8080
+  quilltap -d /mnt/data/quilltap        # Custom data directory
+  quilltap -o                           # Start and open browser
+  quilltap --update                     # Re-download app files
+
+More info: https://quilltap.ai
+`);
+}
+
+function openBrowser(url) {
+  const platform = process.platform;
+  let cmd;
+  if (platform === 'darwin') {
+    cmd = `open "${url}"`;
+  } else if (platform === 'win32') {
+    cmd = `start "" "${url}"`;
+  } else {
+    cmd = `xdg-open "${url}"`;
+  }
+  exec(cmd, (err) => {
+    if (err) {
+      console.log(`Could not open browser automatically. Visit: ${url}`);
+    }
+  });
+}
+
+// Main
+async function main() {
+  const opts = parseArgs(process.argv);
+
+  if (opts.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const version = getVersion();
+
+  if (opts.version) {
+    console.log(version);
+    process.exit(0);
+  }
+
+  // Ensure standalone files are downloaded and cached
+  const cacheDir = getCacheDir();
+  let standaloneDir;
+
+  try {
+    standaloneDir = await ensureStandalone(version, cacheDir, { force: opts.update });
+  } catch (err) {
+    console.error('');
+    console.error(err.message);
+    process.exit(1);
+  }
+
+  const serverJs = path.join(standaloneDir, 'server.js');
+
+  if (!fs.existsSync(serverJs)) {
+    console.error('Error: server.js not found in cached standalone directory.');
+    console.error('Try running "quilltap --update" to re-download.');
+    process.exit(1);
+  }
+
+  // Set up environment
+  const env = {
+    ...process.env,
+    NODE_ENV: 'production',
+    PORT: String(opts.port),
+    HOSTNAME: '0.0.0.0',
+  };
+
+  if (opts.dataDir) {
+    env.QUILLTAP_DATA_DIR = path.resolve(opts.dataDir);
+  }
+
+  // Set NODE_PATH so native modules resolve from the npm package's own node_modules.
+  // The standalone output has native modules stripped — better-sqlite3 and sharp
+  // are installed as real npm dependencies so they compile for the user's platform.
+  const packageNodeModules = path.join(PACKAGE_DIR, 'node_modules');
+  env.NODE_PATH = env.NODE_PATH
+    ? `${packageNodeModules}${path.delimiter}${env.NODE_PATH}`
+    : packageNodeModules;
+
+  const url = `http://localhost:${opts.port}`;
+
+  console.log('');
+  console.log(`  Quilltap v${version}`);
+  console.log('');
+  console.log(`  URL:       ${url}`);
+  if (opts.dataDir) {
+    console.log(`  Data dir:  ${env.QUILLTAP_DATA_DIR}`);
+  }
+  console.log('');
+  console.log('  Starting server...');
+  console.log('');
+
+  // Fork the Next.js standalone server
+  const child = fork(serverJs, [], {
+    cwd: standaloneDir,
+    env,
+    stdio: 'inherit',
+  });
+
+  // Open browser once server is listening
+  if (opts.open) {
+    setTimeout(() => openBrowser(url), 2000);
+  }
+
+  // Forward signals for graceful shutdown
+  function shutdown(signal) {
+    child.kill(signal);
+  }
+
+  process.on('SIGINT', () => shutdown('SIGINT'));
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
+
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.exit(0);
+    }
+    process.exit(code || 0);
+  });
+
+  child.on('error', (err) => {
+    console.error('Failed to start server:', err.message);
+    process.exit(1);
+  });
+}
+
+main();

package/lib/download-manager.js

@@ -0,0 +1,292 @@
+'use strict';
+
+/**
+ * Download manager for the Quilltap standalone tarball.
+ *
+ * On first run (or version mismatch), downloads the pre-built standalone
+ * output from GitHub Releases and caches it locally. Subsequent runs
+ * start instantly from the cache.
+ *
+ * Uses only Node.js built-ins — no external dependencies.
+ */
+
+const https = require('https');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { extractTarGz } = require('./tar-extract');
+
+const MAX_RETRIES = 3;
+const PROGRESS_THROTTLE_MS = 250;
+const GITHUB_REPO = 'foundry-9/quilltap';
+
+/**
+ * Get the platform-specific cache directory for standalone files.
+ * Follows the same conventions as the Electron app.
+ */
+function getCacheDir() {
+  const platform = process.platform;
+
+  if (platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Caches', 'Quilltap', 'standalone');
+  }
+
+  if (platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    return path.join(localAppData, 'Quilltap', 'standalone');
+  }
+
+  // Linux and others: XDG_CACHE_HOME or ~/.cache
+  const cacheHome = process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache');
+  return path.join(cacheHome, 'quilltap', 'standalone');
+}
+
+/**
+ * Check if the cached standalone matches the expected version.
+ * @param {string} cacheDir - The cache directory
+ * @param {string} version - Expected version
+ * @returns {boolean} true if cache is valid and matches version
+ */
+function isCacheValid(cacheDir, version) {
+  const versionFile = path.join(cacheDir, '.version');
+  const serverJs = path.join(cacheDir, 'server.js');
+
+  if (!fs.existsSync(serverJs)) {
+    return false;
+  }
+
+  try {
+    const cachedVersion = fs.readFileSync(versionFile, 'utf-8').trim();
+    return cachedVersion === version;
+  } catch {
+    // No version file — cache is invalid
+    return false;
+  }
+}
+
+/**
+ * Build the download URL for a given version.
+ * @param {string} version
+ * @returns {string}
+ */
+function getDownloadUrl(version) {
+  return `https://github.com/${GITHUB_REPO}/releases/download/${version}/quilltap-standalone-${version}.tar.gz`;
+}
+
+/**
+ * Format bytes into a human-readable string.
+ * @param {number} bytes
+ * @returns {string}
+ */
+function formatBytes(bytes) {
+  if (bytes >= 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+  }
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${bytes} B`;
+}
+
+/**
+ * Format bytes/second into a speed string.
+ * @param {number} bytesPerSecond
+ * @returns {string}
+ */
+function formatSpeed(bytesPerSecond) {
+  if (bytesPerSecond >= 1024 * 1024) {
+    return `${(bytesPerSecond / (1024 * 1024)).toFixed(1)} MB/s`;
+  }
+  if (bytesPerSecond >= 1024) {
+    return `${(bytesPerSecond / 1024).toFixed(1)} KB/s`;
+  }
+  return `${Math.round(bytesPerSecond)} B/s`;
+}
+
+/**
+ * Render a terminal progress bar.
+ * @param {number} percent
+ * @param {number} received
+ * @param {number} total
+ * @param {string} speed
+ */
+function renderProgress(percent, received, total, speed) {
+  const barWidth = 30;
+  const filled = Math.round((percent / 100) * barWidth);
+  const empty = barWidth - filled;
+  const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(empty);
+
+  const totalStr = total > 0 ? formatBytes(total) : '?';
+  const line = `  Downloading: ${bar} ${percent}% (${formatBytes(received)}/${totalStr}) ${speed}`;
+
+  // Clear line and write progress
+  process.stdout.write('\r' + line + '   ');
+}
+
+/**
+ * Download a file from a URL, following redirects.
+ * @param {string} url
+ * @param {string} destPath - Path to save the downloaded file
+ * @returns {Promise<void>}
+ */
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const protocol = url.startsWith('https') ? https : http;
+
+    const request = protocol.get(url, { headers: { 'User-Agent': 'quilltap-cli' } }, (response) => {
+      // Handle redirects (GitHub releases redirect to S3)
+      if (
+        response.statusCode &&
+        response.statusCode >= 300 &&
+        response.statusCode < 400 &&
+        response.headers.location
+      ) {
+        downloadFile(response.headers.location, destPath).then(resolve).catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+        return;
+      }
+
+      const totalBytes = parseInt(response.headers['content-length'] || '0', 10);
+      let bytesReceived = 0;
+      let lastProgressTime = 0;
+      let lastProgressBytes = 0;
+      const startTime = Date.now();
+
+      const tempPath = destPath + '.tmp';
+      const fileStream = fs.createWriteStream(tempPath);
+
+      response.on('data', (chunk) => {
+        bytesReceived += chunk.length;
+
+        const now = Date.now();
+        if (now - lastProgressTime >= PROGRESS_THROTTLE_MS) {
+          const elapsed = (now - lastProgressTime) / 1000;
+          const bytesInPeriod = bytesReceived - lastProgressBytes;
+          const speedBps = elapsed > 0 ? bytesInPeriod / elapsed : 0;
+          const percent = totalBytes > 0 ? Math.round((bytesReceived / totalBytes) * 100) : 0;
+
+          renderProgress(percent, bytesReceived, totalBytes, formatSpeed(speedBps));
+
+          lastProgressTime = now;
+          lastProgressBytes = bytesReceived;
+        }
+      });
+
+      response.pipe(fileStream);
+
+      fileStream.on('finish', () => {
+        fileStream.close(() => {
+          // Clear progress line
+          process.stdout.write('\r' + ' '.repeat(80) + '\r');
+
+          const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+          console.log(`  Downloaded ${formatBytes(bytesReceived)} in ${totalTime}s`);
+
+          // Move temp file to final location
+          fs.renameSync(tempPath, destPath);
+          resolve();
+        });
+      });
+
+      fileStream.on('error', (err) => {
+        try { fs.unlinkSync(tempPath); } catch { /* ignore */ }
+        reject(err);
+      });
+
+      response.on('error', reject);
+    });
+
+    request.on('error', reject);
+  });
+}
+
+/**
+ * Download and extract the standalone tarball for the given version.
+ * Retries with exponential backoff on failure.
+ *
+ * @param {string} version - The version to download
+ * @param {string} cacheDir - The cache directory
+ * @param {object} [options]
+ * @param {boolean} [options.force] - Force re-download even if cache is valid
+ * @returns {Promise<string>} Path to the standalone directory
+ */
+async function ensureStandalone(version, cacheDir, options = {}) {
+  if (!options.force && isCacheValid(cacheDir, version)) {
+    return cacheDir;
+  }
+
+  const url = getDownloadUrl(version);
+  const tarballPath = path.join(os.tmpdir(), `quilltap-standalone-${version}.tar.gz`);
+
+  console.log('');
+  console.log(`  Quilltap v${version} — first-run setup`);
+  console.log('');
+  console.log('  The application files need to be downloaded. This only');
+  console.log('  happens once per version and takes about a minute.');
+  console.log('');
+
+  let lastError;
+
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      await downloadFile(url, tarballPath);
+
+      // Clean existing cache
+      if (fs.existsSync(cacheDir)) {
+        fs.rmSync(cacheDir, { recursive: true, force: true });
+      }
+      fs.mkdirSync(cacheDir, { recursive: true });
+
+      // Extract
+      console.log('  Extracting...');
+      await extractTarGz(tarballPath, cacheDir);
+
+      // Write version sidecar
+      fs.writeFileSync(path.join(cacheDir, '.version'), version, 'utf-8');
+
+      // Clean up tarball
+      try { fs.unlinkSync(tarballPath); } catch { /* ignore */ }
+
+      console.log('  Ready!');
+      console.log('');
+
+      return cacheDir;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      console.error(`  Download attempt ${attempt}/${MAX_RETRIES} failed: ${lastError.message}`);
+
+      // Clean up partial downloads
+      try { fs.unlinkSync(tarballPath); } catch { /* ignore */ }
+
+      if (attempt < MAX_RETRIES) {
+        const delayMs = Math.pow(2, attempt) * 1000;
+        console.log(`  Retrying in ${delayMs / 1000}s...`);
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+  }
+
+  throw new Error(
+    `Failed to download Quilltap standalone after ${MAX_RETRIES} attempts.\n` +
+    `  URL: ${url}\n` +
+    `  Error: ${lastError ? lastError.message : 'Unknown error'}\n\n` +
+    `  Please check your internet connection and try again.\n` +
+    `  If the problem persists, you can download manually from:\n` +
+    `  https://github.com/${GITHUB_REPO}/releases`
+  );
+}
+
+module.exports = {
+  getCacheDir,
+  isCacheValid,
+  ensureStandalone,
+  getDownloadUrl,
+};

package/lib/tar-extract.js

@@ -0,0 +1,226 @@
+'use strict';
+
+/**
+ * Minimal tar.gz extractor using only Node.js built-ins.
+ * Handles POSIX tar format (ustar) — sufficient for extracting
+ * the Quilltap standalone tarball.
+ *
+ * No external dependencies required.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+
+/**
+ * Extract a .tar.gz file to the given directory.
+ * @param {string} tarGzPath - Path to the .tar.gz file
+ * @param {string} destDir - Directory to extract into
+ * @returns {Promise<void>}
+ */
+function extractTarGz(tarGzPath, destDir) {
+  return new Promise((resolve, reject) => {
+    const readStream = fs.createReadStream(tarGzPath);
+    const gunzip = zlib.createGunzip();
+    const chunks = [];
+
+    readStream.pipe(gunzip);
+
+    gunzip.on('data', (chunk) => chunks.push(chunk));
+    gunzip.on('error', reject);
+    readStream.on('error', reject);
+
+    gunzip.on('end', () => {
+      try {
+        const tarBuffer = Buffer.concat(chunks);
+        extractTarBuffer(tarBuffer, destDir);
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  });
+}
+
+/**
+ * Parse and extract files from a raw tar buffer.
+ * @param {Buffer} buffer - The uncompressed tar data
+ * @param {string} destDir - Directory to extract into
+ */
+function extractTarBuffer(buffer, destDir) {
+  let offset = 0;
+
+  while (offset + 512 <= buffer.length) {
+    const header = buffer.subarray(offset, offset + 512);
+
+    // Check for end-of-archive (two consecutive zero blocks)
+    if (isZeroBlock(header)) {
+      break;
+    }
+
+    const parsed = parseHeader(header);
+    if (!parsed) {
+      // Skip malformed header
+      offset += 512;
+      continue;
+    }
+
+    offset += 512; // Move past header
+
+    const { name, size, type, linkName } = parsed;
+
+    // Security: prevent path traversal
+    const safeName = name.replace(/^\.\//, '');
+    if (safeName.startsWith('/') || safeName.includes('..')) {
+      // Skip dangerous paths
+      offset += Math.ceil(size / 512) * 512;
+      continue;
+    }
+
+    const fullPath = path.join(destDir, safeName);
+
+    switch (type) {
+      case 'directory':
+        fs.mkdirSync(fullPath, { recursive: true });
+        break;
+
+      case 'file': {
+        // Ensure parent directory exists
+        const dir = path.dirname(fullPath);
+        fs.mkdirSync(dir, { recursive: true });
+
+        const fileData = buffer.subarray(offset, offset + size);
+        fs.writeFileSync(fullPath, fileData);
+
+        // Set executable permission if needed
+        if (parsed.mode & 0o111) {
+          try {
+            fs.chmodSync(fullPath, parsed.mode);
+          } catch {
+            // chmod may fail on Windows, that's fine
+          }
+        }
+        break;
+      }
+
+      case 'symlink': {
+        const dir = path.dirname(fullPath);
+        fs.mkdirSync(dir, { recursive: true });
+        try {
+          fs.symlinkSync(linkName, fullPath);
+        } catch {
+          // Symlinks may fail on Windows without privileges
+        }
+        break;
+      }
+
+      // Skip other types (hard links, etc.)
+    }
+
+    // Advance past file data (padded to 512-byte boundary)
+    offset += Math.ceil(size / 512) * 512;
+  }
+}
+
+/**
+ * Parse a 512-byte tar header block.
+ * @param {Buffer} header
+ * @returns {{ name: string, size: number, type: string, mode: number, linkName: string } | null}
+ */
+function parseHeader(header) {
+  // Validate checksum
+  const storedChecksum = parseOctal(header, 148, 8);
+  const computedChecksum = computeChecksum(header);
+  if (storedChecksum !== computedChecksum) {
+    return null;
+  }
+
+  const name = parseName(header, 0, 100);
+  const mode = parseOctal(header, 100, 8);
+  const size = parseOctal(header, 124, 12);
+  const typeFlag = String.fromCharCode(header[156]);
+  const linkName = parseName(header, 157, 100);
+
+  // UStar prefix (extends the name field for longer paths)
+  const magic = header.subarray(257, 263).toString('ascii');
+  let fullName = name;
+  if (magic.startsWith('ustar')) {
+    const prefix = parseName(header, 345, 155);
+    if (prefix) {
+      fullName = prefix + '/' + name;
+    }
+  }
+
+  // Determine entry type
+  let type;
+  switch (typeFlag) {
+    case '0':
+    case '\0':
+    case '': // Regular file
+      type = 'file';
+      break;
+    case '2': // Symbolic link
+      type = 'symlink';
+      break;
+    case '5': // Directory
+      type = 'directory';
+      break;
+    default:
+      type = 'other';
+  }
+
+  // A name ending with '/' is also a directory
+  if (fullName.endsWith('/') && type === 'file' && size === 0) {
+    type = 'directory';
+  }
+
+  return { name: fullName, size, type, mode, linkName };
+}
+
+/**
+ * Read a null-terminated string from a buffer region.
+ */
+function parseName(buffer, offset, length) {
+  const slice = buffer.subarray(offset, offset + length);
+  const nullIndex = slice.indexOf(0);
+  const str = slice.subarray(0, nullIndex >= 0 ? nullIndex : length).toString('utf-8');
+  return str;
+}
+
+/**
+ * Parse an octal number from a buffer region.
+ */
+function parseOctal(buffer, offset, length) {
+  const slice = buffer.subarray(offset, offset + length);
+  const str = slice.toString('ascii').replace(/\0/g, '').trim();
+  if (!str) return 0;
+  return parseInt(str, 8) || 0;
+}
+
+/**
+ * Compute the checksum of a tar header (treat checksum field as spaces).
+ */
+function computeChecksum(header) {
+  let sum = 0;
+  for (let i = 0; i < 512; i++) {
+    // The checksum field (bytes 148-155) is treated as spaces (0x20)
+    if (i >= 148 && i < 156) {
+      sum += 0x20;
+    } else {
+      sum += header[i];
+    }
+  }
+  return sum;
+}
+
+/**
+ * Check if a 512-byte block is all zeros.
+ */
+function isZeroBlock(block) {
+  for (let i = 0; i < 512; i++) {
+    if (block[i] !== 0) return false;
+  }
+  return true;
+}
+
+module.exports = { extractTarGz };

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "quilltap",
+  "version": "3.0.0-dev.79",
+  "description": "Self-hosted AI workspace for writers, worldbuilders, and roleplayers. Run with npx quilltap.",
+  "author": {
+    "name": "Charles Sebold",
+    "email": "charles.sebold@foundry-9.com",
+    "url": "https://foundry-9.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/foundry-9/quilltap.git",
+    "directory": "packages/quilltap"
+  },
+  "homepage": "https://quilltap.ai",
+  "keywords": [
+    "quilltap",
+    "ai",
+    "llm",
+    "chat",
+    "roleplay",
+    "writing",
+    "worldbuilding",
+    "self-hosted"
+  ],
+  "bin": {
+    "quilltap": "bin/quilltap.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
+  "dependencies": {
+    "better-sqlite3": "^12.6.2",
+    "sharp": "^0.34.5"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}