100xprompt-cli 0.1.72

package/LICENSE

@@ -0,0 +1,35 @@
+100xprompt
+Copyright (c) 2025 100xprompt
+
+All rights reserved, except as required by the upstream licence reproduced
+below. 100xprompt is a derivative work of opencode. MIT permits sublicensing
+under different terms provided the original copyright and permission notice are
+retained — that is the purpose of the second section of this file. See NOTICE
+for the full list of third-party components bundled into the binary.
+
+
+================================================================================
+UPSTREAM — opencode (https://github.com/sst/opencode)
+================================================================================
+
+MIT License
+
+Copyright (c) 2025 opencode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,68 @@
+NOTICE — third-party components distributed with 100xprompt
+================================================================================
+
+This file lists third-party material bundled into the 100xprompt binary or the
+published npm packages. It is a companion to LICENSE, which carries the upstream
+copyright notice for the opencode-derived portions of this software.
+
+Where a licence is stated as "not verified", the entry is recorded from general
+knowledge rather than from the upstream project's own licence file, and should
+be confirmed before anyone relies on it. Recording an unverified attribution is
+better than recording none; it is not a substitute for checking.
+
+
+1. DERIVED FROM
+--------------------------------------------------------------------------------
+
+opencode — https://github.com/sst/opencode — MIT
+    100xprompt is a derivative work of opencode. Its copyright and permission
+    notice are reproduced in full in LICENSE.
+
+
+2. TREE-SITTER GRAMMARS (compiled into the binary as build assets)
+--------------------------------------------------------------------------------
+
+The syntax highlighter embeds compiled tree-sitter grammars and their query
+files. Each comes from a separate upstream project with its own licence:
+
+    bash, go, javascript, json, python, rust, tsx, typescript
+        tree-sitter grammar projects (github.com/tree-sitter/*)
+    markdown, markdown_inline
+        github.com/tree-sitter-grammars/tree-sitter-markdown
+
+The `.scm` query files vendored alongside each grammar originate from those same
+projects, except the markdown highlight queries, which are 100xprompt's own —
+see packages/tui/scripts/queries/. The runtime is web-tree-sitter (MIT).
+
+Regenerate with: bun run --cwd packages/tui vendor-grammars
+
+
+3. TERMINAL COLOUR SCHEMES
+--------------------------------------------------------------------------------
+
+The bundled themes are ports of third-party colour schemes. The palettes are the
+work of their original authors; only the mapping to our theme format is ours:
+
+    aura, ayu, catppuccin (frappe/macchiato), cobalt2, cursor, dracula,
+    everforest, flexoki, github, gruvbox, kanagawa, material, monokai,
+    nightowl, nord, one-dark, osaka-jade, palenight, rosepine, solarized,
+    synthwave84, tokyonight, vercel, vesper, zenburn
+
+    100xprompt, lucent-orng, matrix, mercury, orng — original to this project.
+
+Two need attention before redistribution and are flagged here rather than
+quietly shipped:
+
+    tokyonight   Apache-2.0, NOT MIT. Apache-2.0 carries NOTICE-file and
+                 change-statement obligations that a blanket permissive
+                 assumption does not satisfy.
+    monokai      The original TextMate theme was never clearly licensed and the
+                 name is claimed as a trademark.
+
+
+4. RUNTIME DEPENDENCIES
+--------------------------------------------------------------------------------
+
+Ordinary npm dependencies (react, react-reconciler, web-tree-sitter and others)
+are not vendored. Their licences travel with their own packages in node_modules
+and are not reproduced here.

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,41 @@
+{
+  "name": "100xprompt-cli",
+  "version": "0.1.72",
+  "description": "Multi-model terminal coding agent. Route work across Claude, GLM, Gemini, DeepSeek and local models from one harness.",
+  "license": "UNLICENSED",
+  "author": "100XPrompt",
+  "homepage": "https://100xprompt.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nipurn123/100xprompt.git",
+    "directory": "packages/100xprompt"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "cli",
+    "coding-agent",
+    "llm",
+    "tui",
+    "100xprompt"
+  ],
+  "bin": {
+    "100xprompt": "bin/100xprompt.js"
+  },
+  "scripts": {
+    "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
+  },
+  "optionalDependencies": {
+    "@100xprompt/cli-linux-arm64": "0.1.72",
+    "@100xprompt/cli-linux-x64": "0.1.72",
+    "@100xprompt/cli-linux-x64-baseline": "0.1.72",
+    "@100xprompt/cli-linux-arm64-musl": "0.1.72",
+    "@100xprompt/cli-linux-x64-musl": "0.1.72",
+    "@100xprompt/cli-linux-x64-baseline-musl": "0.1.72",
+    "@100xprompt/cli-darwin-arm64": "0.1.72",
+    "@100xprompt/cli-darwin-x64": "0.1.72",
+    "@100xprompt/cli-darwin-x64-baseline": "0.1.72",
+    "@100xprompt/cli-windows-x64": "0.1.72",
+    "@100xprompt/cli-windows-x64-baseline": "0.1.72"
+  }
+}

package/postinstall.mjs

@@ -0,0 +1,372 @@
+#!/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)
+})