@seflless/ghosttown 1.3.0 → 1.3.1

package/bin/ght.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+/**
+ * ght - Alternative alias for ghosttown CLI
+ *
+ * This is a thin wrapper that delegates to the shared CLI implementation.
+ * Primary command: ghosttown
+ * Short alias: gt
+ */
+
+import { run } from '../src/cli.js';
+
+run(process.argv);

package/bin/gt.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+/**
+ * gt - Short alias for ghosttown CLI
+ *
+ * This is a thin wrapper that delegates to the shared CLI implementation.
+ * Primary command: ghosttown
+ * Alternative alias: ght
+ */
+
+import { run } from '../src/cli.js';
+
+run(process.argv);

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "@seflless/ghosttown",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Web-based terminal emulator using Ghostty's VT100 parser via WebAssembly",
   "type": "module",
   "main": "./dist/ghostty-web.umd.cjs",
   "module": "./dist/ghostty-web.js",
   "types": "./dist/index.d.ts",
   "bin": {
-    "ghosttown": "./bin/ghosttown.js"
+    "ghosttown": "./bin/ghosttown.js",
+    "gt": "./bin/gt.js",
+    "ght": "./bin/ght.js"
   },
   "exports": {
     ".": {
@@ -20,6 +22,8 @@
   "files": [
     "bin",
     "dist",
+    "scripts",
+    "src",
     "ghostty-vt.wasm",
     "README.md"
   ],
@@ -47,6 +51,7 @@
     "access": "public"
   },
   "scripts": {
+    "postinstall": "node ./scripts/postinstall.js",
     "dev": "vite --port 8000",
     "demo": "node demo/bin/demo.js",
     "demo:dev": "node demo/bin/demo.js --dev",

package/scripts/build-wasm.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+set -euo pipefail
+
+echo "🔨 Building ghostty-vt.wasm..."
+
+# Check for Zig
+if ! command -v zig &> /dev/null; then
+    echo "❌ Error: Zig not found"
+    echo ""
+    echo "Install Zig 0.15.2+:"
+    echo "  macOS:   brew install zig"
+    echo "  Linux:   https://ziglang.org/download/"
+    echo ""
+    exit 1
+fi
+
+ZIG_VERSION=$(zig version)
+echo "✓ Found Zig $ZIG_VERSION"
+
+# Initialize/update submodule
+if [ ! -d "ghostty/.git" ]; then
+    echo "📦 Initializing Ghostty submodule..."
+    git submodule update --init --recursive
+else
+    echo "📦 Ghostty submodule already initialized"
+fi
+
+# Apply patch
+echo "🔧 Applying WASM API patch..."
+cd ghostty
+git apply --check ../patches/ghostty-wasm-api.patch || {
+    echo "❌ Patch doesn't apply cleanly"
+    echo "Ghostty may have changed. Check patches/ghostty-wasm-api.patch"
+    exit 1
+}
+git apply ../patches/ghostty-wasm-api.patch
+
+# Build WASM
+echo "⚙️  Building WASM (takes ~20 seconds)..."
+zig build lib-vt -Dtarget=wasm32-freestanding -Doptimize=ReleaseSmall
+
+# Copy to project root
+cd ..
+cp ghostty/zig-out/bin/ghostty-vt.wasm ./
+
+# Revert patch to keep submodule clean
+echo "🧹 Cleaning up..."
+cd ghostty
+git apply -R ../patches/ghostty-wasm-api.patch
+# Remove new files created by the patch
+rm -f include/ghostty/vt/terminal.h
+rm -f src/terminal/c/terminal.zig
+cd ..
+
+SIZE=$(du -h ghostty-vt.wasm | cut -f1)
+echo "✅ Built ghostty-vt.wasm ($SIZE)"

package/scripts/cli-publish.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+
+/**
+ * CLI Publish Script
+ *
+ * Full release workflow:
+ * 1. Build the project
+ * 2. Bump version (patch|minor|major)
+ * 3. Create branch francois/version-bump-<version>
+ * 4. Commit package.json version change
+ * 5. Publish to npm with --access public
+ * 6. Tag with v<version>
+ * 7. Push branch and tags
+ * 8. Create GitHub release (latest)
+ * 9. Create Draft PR
+ *
+ * Usage: bun cli:publish [patch|minor|major]
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const rootDir = path.join(__dirname, '..');
+
+function run(cmd, options = {}) {
+  console.log(`\n$ ${cmd}`);
+  try {
+    const result = execSync(cmd, {
+      cwd: rootDir,
+      stdio: options.silent ? 'pipe' : 'inherit',
+      encoding: 'utf-8',
+      ...options,
+    });
+    return result;
+  } catch (error) {
+    if (options.ignoreError) {
+      return null;
+    }
+    console.error(`\nCommand failed: ${cmd}`);
+    process.exit(1);
+  }
+}
+
+function getPackageJson() {
+  const packagePath = path.join(rootDir, 'package.json');
+  return JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+}
+
+function setPackageVersion(version) {
+  const packagePath = path.join(rootDir, 'package.json');
+  const pkg = getPackageJson();
+  pkg.version = version;
+  fs.writeFileSync(packagePath, JSON.stringify(pkg, null, 2) + '\n');
+}
+
+function bumpVersion(currentVersion, type) {
+  const [major, minor, patch] = currentVersion.split('.').map(Number);
+
+  switch (type) {
+    case 'major':
+      return `${major + 1}.0.0`;
+    case 'minor':
+      return `${major}.${minor + 1}.0`;
+    case 'patch':
+      return `${major}.${minor}.${patch + 1}`;
+    default:
+      console.error(`Invalid version type: ${type}. Use patch, minor, or major.`);
+      process.exit(1);
+  }
+}
+
+async function main() {
+  const versionType = process.argv[2] || 'patch';
+
+  if (!['patch', 'minor', 'major'].includes(versionType)) {
+    console.error('Usage: bun cli:publish [patch|minor|major]');
+    console.error('  patch - Bug fixes (1.0.0 -> 1.0.1)');
+    console.error('  minor - New features (1.0.0 -> 1.1.0)');
+    console.error('  major - Breaking changes (1.0.0 -> 2.0.0)');
+    process.exit(1);
+  }
+
+  // Check for uncommitted changes
+  const status = run('git status --porcelain', { silent: true });
+  if (status && status.trim()) {
+    console.error('\nError: You have uncommitted changes. Please commit or stash them first.');
+    process.exit(1);
+  }
+
+  // Check we're on main branch
+  const currentBranch = run('git branch --show-current', { silent: true }).trim();
+  if (currentBranch !== 'main') {
+    console.error(
+      `\nError: You must be on the main branch to publish. Currently on: ${currentBranch}`
+    );
+    process.exit(1);
+  }
+
+  // Pull latest
+  console.log('\n📥 Pulling latest changes...');
+  run('git pull origin main');
+
+  // Get current version and calculate new version
+  const pkg = getPackageJson();
+  const currentVersion = pkg.version;
+  const newVersion = bumpVersion(currentVersion, versionType);
+  const branchName = `francois/version-bump-${newVersion}`;
+  const tagName = `v${newVersion}`;
+
+  console.log('\n📋 Release Plan:');
+  console.log(`   Package: ${pkg.name}`);
+  console.log(`   Current version: ${currentVersion}`);
+  console.log(`   New version: ${newVersion} (${versionType})`);
+  console.log(`   Branch: ${branchName}`);
+  console.log(`   Tag: ${tagName}`);
+
+  // Step 1: Build
+  console.log('\n🔨 Building project...');
+  run('bun run build');
+
+  // Step 2: Bump version
+  console.log(`\n📝 Bumping version to ${newVersion}...`);
+  setPackageVersion(newVersion);
+
+  // Step 3: Create branch
+  console.log(`\n🌿 Creating branch ${branchName}...`);
+  run(`git checkout -b ${branchName}`);
+
+  // Step 4: Commit
+  console.log('\n💾 Committing version bump...');
+  run('git add package.json');
+  run(`git commit -m "chore: bump version to ${newVersion}"`);
+
+  // Step 5: Publish to npm
+  console.log('\n📦 Publishing to npm...');
+  run('npm publish --access public');
+
+  // Step 6: Tag
+  console.log(`\n🏷️  Creating tag ${tagName}...`);
+  run(`git tag -a ${tagName} -m "Release ${tagName}"`);
+
+  // Step 7: Push branch and tags
+  console.log('\n🚀 Pushing branch and tags...');
+  run(`git push -u origin ${branchName}`);
+  run('git push --tags');
+
+  // Step 8: Create GitHub release
+  console.log('\n📢 Creating GitHub release...');
+  const releaseNotes = `## ${pkg.name} ${tagName}
+
+### Installation
+
+\`\`\`bash
+# Install globally
+npm install -g ${pkg.name}
+
+# Or use npx
+npx ${pkg.name}
+\`\`\`
+
+### Run
+
+\`\`\`bash
+ghosttown
+\`\`\`
+
+Opens http://localhost:8080 with a web-based terminal.
+`;
+
+  // Write release notes to temp file to avoid shell escaping issues
+  const tempFile = path.join(rootDir, '.release-notes-temp.md');
+  fs.writeFileSync(tempFile, releaseNotes);
+
+  run(`gh release create ${tagName} --title "${tagName}" --notes-file "${tempFile}" --latest`);
+
+  // Clean up temp file
+  fs.unlinkSync(tempFile);
+
+  // Step 9: Create Draft PR
+  console.log('\n📝 Creating Draft PR...');
+  const prBody = `## Summary
+- Bumps version from ${currentVersion} to ${newVersion}
+
+## Checklist
+- [x] Built successfully
+- [x] Published to npm
+- [x] Tagged ${tagName}
+- [x] GitHub release created
+
+## npm
+https://www.npmjs.com/package/${pkg.name}
+`;
+
+  const tempPrFile = path.join(rootDir, '.pr-body-temp.md');
+  fs.writeFileSync(tempPrFile, prBody);
+
+  const prUrl = run(
+    `gh pr create --draft --title "chore: bump version to ${newVersion}" --body-file "${tempPrFile}"`,
+    { silent: true }
+  );
+
+  // Clean up temp file
+  fs.unlinkSync(tempPrFile);
+
+  // Done!
+  console.log('\n' + '═'.repeat(50));
+  console.log('  ✅ Release complete!');
+  console.log('═'.repeat(50));
+  console.log(`\n  📦 npm: https://www.npmjs.com/package/${pkg.name}`);
+  console.log(`  🏷️  Tag: ${tagName}`);
+  console.log(`  🌿 Branch: ${branchName}`);
+  if (prUrl) {
+    console.log(`  📝 PR: ${prUrl.trim()}`);
+  }
+  console.log('\n  Next steps:');
+  console.log('  1. Review and merge the PR');
+  console.log('  2. Switch back to main: git checkout main && git pull');
+  console.log('');
+}
+
+main().catch((error) => {
+  console.error('Unexpected error:', error);
+  process.exit(1);
+});

package/scripts/postinstall.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+
+/**
+ * postinstall script for ghosttown
+ *
+ * Detects if an existing 'gt' command exists on PATH and prints a warning
+ * if it appears to belong to a different package.
+ *
+ * This script is non-blocking and will never fail the install.
+ * macOS/Linux only.
+ */
+
+import { execSync } from 'child_process';
+
+/**
+ * Check if we're on a supported platform (macOS or Linux)
+ */
+function isSupportedPlatform() {
+  return process.platform === 'darwin' || process.platform === 'linux';
+}
+
+/**
+ * Resolve the path of a command using 'command -v'
+ * Returns null if the command is not found
+ */
+function resolveCommand(cmd) {
+  try {
+    const result = execSync(`command -v ${cmd}`, {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return result.trim();
+  } catch (err) {
+    // Command not found
+    return null;
+  }
+}
+
+/**
+ * Check if a resolved path likely belongs to this package
+ */
+function isOurCommand(resolvedPath) {
+  if (!resolvedPath) return false;
+
+  // Check if the path contains indicators that it's from our package
+  const indicators = [
+    'node_modules/ghosttown',
+    'node_modules/@seflless/ghosttown',
+    '/ghosttown/bin/gt',
+  ];
+
+  const normalizedPath = resolvedPath.toLowerCase();
+  return indicators.some((indicator) => normalizedPath.includes(indicator.toLowerCase()));
+}
+
+/**
+ * Print the conflict warning message
+ */
+function printWarning(resolvedPath) {
+  const YELLOW = '\x1b[33m';
+  const CYAN = '\x1b[36m';
+  const DIM = '\x1b[2m';
+  const RESET = '\x1b[0m';
+
+  console.log('');
+  console.log(`${YELLOW}\u26a0\ufe0f  ghosttown: 'gt' command conflict detected${RESET}`);
+  console.log('');
+  console.log(`An existing 'gt' command was found on your PATH:`);
+  console.log(`  ${DIM}${resolvedPath}${RESET}`);
+  console.log('');
+  console.log(`ghosttown also provides a 'gt' alias. Depending on PATH order,`);
+  console.log(`one may shadow the other.`);
+  console.log('');
+  console.log(`${CYAN}Primary command:${RESET}    ghosttown`);
+  console.log(`${CYAN}Alternative alias:${RESET}  ght`);
+  console.log('');
+  console.log(`${DIM}Manual alias (optional):${RESET}`);
+  console.log(`  ${DIM}alias gt=ghosttown${RESET}`);
+  console.log('');
+}
+
+/**
+ * Main function - detect gt conflicts
+ */
+function main() {
+  try {
+    // Skip on unsupported platforms
+    if (!isSupportedPlatform()) {
+      return;
+    }
+
+    // Check if gt command exists
+    const gtPath = resolveCommand('gt');
+
+    // If gt doesn't exist, nothing to warn about
+    if (!gtPath) {
+      return;
+    }
+
+    // If it appears to be ours, no warning needed
+    if (isOurCommand(gtPath)) {
+      return;
+    }
+
+    // Print the warning
+    printWarning(gtPath);
+  } catch (err) {
+    // Swallow all errors - postinstall must never fail
+    // This is a best-effort warning only
+  }
+}
+
+main();