100xprompt-cli 0.1.5

package/bin/100xprompt.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+const { spawn } = require('child_process')
+const path = require('path')
+const fs = require('fs')
+
+function getPlatformPackageName() {
+  const platform = process.platform
+  const arch = process.arch
+  const isMusl = process.report?.getReport?.()?.header?.glibcVersionRuntime === undefined
+  
+  let osName
+  if (platform === 'darwin') osName = 'darwin'
+  else if (platform === 'linux') osName = 'linux'
+  else if (platform === 'win32') osName = 'windows'
+  
+  let pkgName = `@100xprompt/cli-${osName}-${arch}`
+  if (platform === 'linux' && isMusl) {
+    pkgName = `@100xprompt/cli-linux-${arch}-musl`
+  }
+  
+  return pkgName
+}
+
+function findBinary() {
+  const pkgName = getPlatformPackageName()
+  const possiblePaths = [
+    path.join(__dirname, '..', '..', pkgName, 'bin', '100xprompt'),
+    path.join(__dirname, '..', '..', pkgName, 'bin', '100xprompt.exe'),
+    path.join(__dirname, '..', '..', 'node_modules', pkgName, 'bin', '100xprompt'),
+    path.join(__dirname, '..', '..', 'node_modules', pkgName, 'bin', '100xprompt.exe'),
+  ]
+  
+  for (const p of possiblePaths) {
+    if (fs.existsSync(p)) return p
+  }
+  
+  try {
+    const pkgPath = require.resolve(pkgName + '/package.json')
+    const binPath = path.join(path.dirname(pkgPath), 'bin', '100xprompt')
+    if (fs.existsSync(binPath)) return binPath
+    if (fs.existsSync(binPath + '.exe')) return binPath + '.exe'
+  } catch {}
+  
+  return null
+}
+
+const binaryPath = findBinary()
+if (!binaryPath) {
+  console.error(`Could not find binary for platform: ${getPlatformPackageName()}`)
+  process.exit(1)
+}
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  env: process.env
+})
+
+child.on('error', (err) => {
+  console.error('[100XPrompt] Failed to start:', err.message)
+  process.exit(1)
+})
+
+child.on('exit', (code, signal) => {
+  if (signal) {
+    console.error(`[100XPrompt] Process was killed with signal: ${signal}`)
+    process.exit(1)
+  }
+  process.exit(code || 0)
+})

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "100xprompt-cli",
+  "version": "0.1.5",
+  "bin": {
+    "100xprompt": "bin/100xprompt.js"
+  },
+  "scripts": {
+    "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
+  },
+  "optionalDependencies": {
+    "@100xprompt/cli-linux-arm64": "0.1.5",
+    "@100xprompt/cli-linux-x64": "0.1.5",
+    "@100xprompt/cli-linux-x64-baseline": "0.1.5",
+    "@100xprompt/cli-linux-arm64-musl": "0.1.5",
+    "@100xprompt/cli-linux-x64-musl": "0.1.5",
+    "@100xprompt/cli-linux-x64-baseline-musl": "0.1.5",
+    "@100xprompt/cli-darwin-arm64": "0.1.5",
+    "@100xprompt/cli-darwin-x64": "0.1.5",
+    "@100xprompt/cli-darwin-x64-baseline": "0.1.5",
+    "@100xprompt/cli-windows-x64": "0.1.5",
+    "@100xprompt/cli-windows-x64-baseline": "0.1.5"
+  }
+}

package/postinstall.mjs

@@ -0,0 +1,366 @@
+#!/usr/bin/env node
+
+import fs from "fs"
+import path from "path"
+import os from "os"
+import { execFileSync } from "child_process"
+import { fileURLToPath } from "url"
+import { createRequire } from "module"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+
+function detectPlatformAndArch() {
+  // Map platform names
+  let platform
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin"
+      break
+    case "linux":
+      platform = "linux"
+      break
+    case "win32":
+      platform = "windows"
+      break
+    default:
+      platform = os.platform()
+      break
+  }
+
+  // Map architecture names
+  let arch
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64"
+      break
+    case "arm64":
+      arch = "arm64"
+      break
+    case "arm":
+      arch = "arm"
+      break
+    default:
+      arch = os.arch()
+      break
+  }
+
+  // glibc vs musl matters for the Linux build variant. When the runtime report
+  // exposes no glibc version, we're on a musl libc (Alpine, etc).
+  let isMusl = false
+  if (platform === "linux") {
+    try {
+      isMusl = process.report?.getReport?.()?.header?.glibcVersionRuntime === undefined
+    } catch {
+      isMusl = false
+    }
+  }
+
+  return { platform, arch, isMusl }
+}
+
+// Candidate platform-package names, in preference order. Mirrors the runtime
+// wrapper (bin/100xprompt.js) and also probes the `-baseline` variant as a
+// fallback for older CPUs without AVX2.
+function candidatePackageNames() {
+  const { platform, arch, isMusl } = detectPlatformAndArch()
+  const base = `@100xprompt/cli-${platform}-${arch}`
+  const names = []
+  if (platform === "linux" && isMusl) {
+    names.push(`${base}-musl`, `${base}-baseline-musl`)
+  }
+  names.push(base, `${base}-baseline`)
+  return names
+}
+
+function findBinary() {
+  const { platform } = detectPlatformAndArch()
+  const binaryName = platform === "windows" ? "100xprompt.exe" : "100xprompt"
+
+  for (const packageName of candidatePackageNames()) {
+    // Probe common install layouts (sibling package, hoisted node_modules,
+    // and require.resolve) so we work under npm/bun/pnpm/yarn and global installs.
+    const candidates = []
+    try {
+      const packageJsonPath = require.resolve(`${packageName}/package.json`)
+      candidates.push(path.join(path.dirname(packageJsonPath), "bin", binaryName))
+    } catch {
+      /* not resolvable from here — fall through to path probing */
+    }
+    candidates.push(
+      path.join(__dirname, "..", packageName, "bin", binaryName),
+      path.join(__dirname, "node_modules", packageName, "bin", binaryName),
+      path.join(__dirname, "..", "node_modules", packageName, "bin", binaryName),
+      path.join(__dirname, "..", "..", packageName, "bin", binaryName),
+      path.join(__dirname, "..", "..", "node_modules", packageName, "bin", binaryName),
+    )
+
+    for (const binaryPath of candidates) {
+      if (fs.existsSync(binaryPath)) {
+        return { binaryPath, binaryName }
+      }
+    }
+  }
+
+  throw new Error(
+    `Could not find platform binary (tried: ${candidatePackageNames().join(", ")})`,
+  )
+}
+
+// The bun-compiled binary must be executable for the wrapper's spawn() to run it
+// without the user ever needing sudo. npm/tar can drop the +x bit on some
+// installs, so re-assert it here. Best-effort: never throw.
+function ensureExecutable(binaryPath) {
+  try {
+    fs.chmodSync(binaryPath, 0o755)
+  } catch (err) {
+    console.warn(`Could not set executable bit on ${binaryPath}: ${err.message}`)
+  }
+}
+
+// macOS kills unsigned/foreign-signed binaries with SIGKILL. Ad-hoc re-sign the
+// binary in place so it runs without Gatekeeper intervention (and without sudo).
+// Best-effort: codesign may be absent or the file read-only — never fail install.
+function codesignDarwin(binaryPath) {
+  if (os.platform() !== "darwin") return
+  try {
+    execFileSync("codesign", ["--remove-signature", binaryPath], { stdio: "ignore" })
+  } catch {
+    /* nothing to remove — fine */
+  }
+  try {
+    execFileSync(
+      "codesign",
+      ["--sign", "-", "--force", "--preserve-metadata=entitlements,requirements,flags,runtime", binaryPath],
+      { stdio: "ignore" },
+    )
+  } catch (err) {
+    console.warn(`Could not ad-hoc sign ${binaryPath}: ${err.message}`)
+  }
+}
+
+function prepareBinDirectory(binaryName) {
+  const binDir = path.join(__dirname, "bin")
+  const targetPath = path.join(binDir, binaryName)
+
+  // Ensure bin directory exists
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true })
+  }
+
+  // Remove existing binary/symlink if it exists
+  if (fs.existsSync(targetPath) || fs.lstatSync(targetPath, { throwIfNoEntry: false })) {
+    try {
+      fs.unlinkSync(targetPath)
+    } catch {
+      /* ignore — overwritten below */
+    }
+  }
+
+  return { binDir, targetPath }
+}
+
+// Make the platform binary reachable at <pkg>/bin/<name>. Prefer a symlink; if
+// the filesystem/permissions reject symlinks (Windows without dev mode, locked
+// dirs), copy instead. The runtime wrapper resolves the binary on its own, so a
+// failure here is non-fatal and must never break the npm install.
+function linkBinary(sourcePath, binaryName) {
+  let targetPath
+  try {
+    ;({ targetPath } = prepareBinDirectory(binaryName))
+  } catch (err) {
+    console.warn(`Could not prepare bin directory: ${err.message}`)
+    return
+  }
+
+  try {
+    fs.symlinkSync(sourcePath, targetPath)
+    console.log(`100xprompt binary symlinked: ${targetPath} -> ${sourcePath}`)
+  } catch (symlinkErr) {
+    try {
+      fs.copyFileSync(sourcePath, targetPath)
+      ensureExecutable(targetPath)
+      console.log(`100xprompt binary copied: ${targetPath}`)
+    } catch (copyErr) {
+      // Wrapper still resolves the binary directly; just warn.
+      console.warn(`Could not link binary (symlink: ${symlinkErr.message}; copy: ${copyErr.message})`)
+    }
+  }
+}
+
+function createConfig() {
+  const home = os.homedir()
+  // Primary: XDG config path (what the app reads via xdg-basedir)
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME || path.join(home, ".config")
+  const configDir = path.join(xdgConfigHome, "100xprompt")
+  const configPath = path.join(configDir, "100xprompt.json")
+  // Legacy fallback: also check ~/.100xprompt
+  const legacyConfigDir = path.join(home, ".100xprompt")
+  const legacyConfigPath = path.join(legacyConfigDir, "100xprompt.json")
+
+  const defaultConfig = {
+    $schema: "https://proxy.100xprompt.com/config.json",
+    compaction: {
+      auto: {
+        enabled: true,
+        // Base auto-compaction threshold. The code uses model-aware thresholds:
+        // Pro ~160k, Flash ~500k; this value is the fallback for other models.
+        compactionThreshold: 160000,
+        tailPreserveTurns: 5,
+      },
+      micro: {
+        enabled: true,
+        hotTailCount: 5,
+      },
+    },
+  }
+
+  try {
+    // Determine which config path to use:
+    // If legacy path exists but XDG path doesn't, use legacy for validation/merge
+    // Otherwise prefer XDG path (the app reads from both)
+    let activeConfigDir = configDir
+    let activeConfigPath = configPath
+    if (fs.existsSync(legacyConfigPath) && !fs.existsSync(configPath)) {
+      activeConfigDir = legacyConfigDir
+      activeConfigPath = legacyConfigPath
+    }
+
+    if (!fs.existsSync(activeConfigDir)) {
+      fs.mkdirSync(activeConfigDir, { recursive: true })
+    }
+
+    if (fs.existsSync(activeConfigPath)) {
+      // Validate existing config and merge missing defaults
+      try {
+        const raw = fs.readFileSync(activeConfigPath, "utf-8")
+        const existing = JSON.parse(raw)
+
+        let needsUpdate = false
+
+        // Ensure compaction section exists with all required fields
+        if (!existing.compaction) {
+          existing.compaction = defaultConfig.compaction
+          needsUpdate = true
+        } else {
+          if (!existing.compaction.auto) {
+            existing.compaction.auto = defaultConfig.compaction.auto
+            needsUpdate = true
+          } else {
+            // Merge individual auto fields if missing
+            for (const [key, value] of Object.entries(defaultConfig.compaction.auto)) {
+              if (existing.compaction.auto[key] === undefined) {
+                existing.compaction.auto[key] = value
+                needsUpdate = true
+              }
+            }
+          }
+          if (!existing.compaction.micro) {
+            existing.compaction.micro = defaultConfig.compaction.micro
+            needsUpdate = true
+          }
+        }
+
+        if (!existing.$schema) {
+          existing.$schema = defaultConfig.$schema
+          needsUpdate = true
+        }
+
+        if (needsUpdate) {
+          fs.writeFileSync(activeConfigPath, JSON.stringify(existing, null, 2))
+          try { fs.chmodSync(activeConfigPath, 0o644) } catch { }
+          console.log(`Config updated with missing defaults at ${activeConfigPath}`)
+        } else {
+          console.log(`Config already exists and is valid at ${activeConfigPath}, skipping.`)
+        }
+      } catch (parseError) {
+        // Existing file is corrupt — back it up and recreate
+        const backupPath = activeConfigPath + ".bak"
+        console.warn(`Config at ${activeConfigPath} is corrupt, backing up to ${backupPath} and recreating.`)
+        try { fs.copyFileSync(activeConfigPath, backupPath) } catch { }
+        fs.writeFileSync(activeConfigPath, JSON.stringify(defaultConfig, null, 2))
+        try { fs.chmodSync(activeConfigPath, 0o644) } catch { }
+        console.log(`Default config recreated at ${activeConfigPath}`)
+      }
+      return
+    }
+
+    fs.writeFileSync(activeConfigPath, JSON.stringify(defaultConfig, null, 2))
+    try { fs.chmodSync(activeConfigPath, 0o644) } catch { }
+    console.log(`Default config created at ${activeConfigPath}`)
+  } catch (error) {
+    console.warn(`Failed to create default config: ${error.message}`)
+    // Don't fail postinstall just because config creation failed
+  }
+}
+
+function buildBanner(color) {
+  const p = (code, s) => (color ? `\x1b[${code}m${s}\x1b[0m` : s)
+  const bold = (s) => p("1", s)
+  const dim = (s) => p("2", s)
+  const accent = (s) => p("38;5;215", s) // soft orange
+  const violet = (s) => p("38;5;141", s)
+  const cyan = (s) => p("38;5;117", s)
+  const green = (s) => p("38;5;114", s)
+  const pink = (s) => p("38;5;213", s)
+
+  const rule = violet("  " + "━".repeat(48))
+  const cmd = color ? `\x1b[1m\x1b[30m\x1b[48;5;215m 100xprompt \x1b[0m` : "100xprompt"
+
+  return [
+    "",
+    rule,
+    "",
+    `    ${accent("✦")}  ${bold("100XPrompt Pro")}  ${dim("· AI coding assistant in your terminal")}`,
+    "",
+    `    ${green("▸")}  Run  ${cmd}  ${dim("to launch")}`,
+    `    ${dim("   then type your first prompt and hit enter")}`,
+    "",
+    `    ${dim("made with")} ${pink("♥")} ${dim("by the")} ${cyan("100xprompt")} ${dim("team")}`,
+    "",
+    rule,
+    "",
+    "",
+  ].join("\n")
+}
+
+function printBanner() {
+  // npm hides postinstall stdout by default, so write straight to the controlling
+  // terminal (/dev/tty) — that bypasses npm's capture and shows the banner on install.
+  try {
+    fs.writeFileSync("/dev/tty", buildBanner(true))
+  } catch {
+    process.stdout.write(buildBanner(!!process.stdout.isTTY))
+  }
+}
+
+async function main() {
+  // Binary setup is best-effort: the runtime wrapper (bin/100xprompt.js) resolves
+  // and launches the platform binary on its own, so postinstall must NEVER fail
+  // the npm install — a non-zero exit is exactly what pushes users to retry with
+  // sudo. We only normalize permissions/signing so the binary runs unprivileged.
+  try {
+    const { binaryPath, binaryName } = findBinary()
+    ensureExecutable(binaryPath) // fixes "permission denied" → no sudo needed to run
+    codesignDarwin(binaryPath) // prevents macOS SIGKILL of the unsigned binary
+    linkBinary(binaryPath, binaryName)
+  } catch (error) {
+    // Don't fail — the wrapper still finds the binary at runtime.
+    console.warn(`100xprompt binary setup skipped: ${error.message}`)
+  }
+
+  try {
+    createConfig()
+  } catch (error) {
+    console.warn(`Config setup skipped: ${error.message}`)
+  }
+
+  printBanner()
+}
+
+main().catch((error) => {
+  // Always exit 0: a failed postinstall blocks the whole install and is the
+  // reason users reach for sudo. Never let that happen.
+  console.warn("Postinstall completed with warnings:", error?.message ?? error)
+  process.exit(0)
+})