@twigpine/openclaude 0.0.0-stage → 0.32.0

package/bin/heap-limit.mjs

@@ -0,0 +1,220 @@
+import os from 'node:os'
+
+export const HEAP_SIZE_ENV = 'OPENCLAUDE_NODE_MAX_OLD_SPACE_SIZE_MB'
+export const HEAP_PERCENTAGE_ENV = 'OPENCLAUDE_NODE_MAX_OLD_SPACE_SIZE_PERCENTAGE'
+export const DEFAULT_HEAP_SIZE_MB = 8192
+export const HEAP_SIZE_FLAG = '--max-old-space-size'
+export const HEAP_PERCENTAGE_FLAG = '--max-old-space-size-percentage'
+export const MAX_MEMORY_FLAG = '--max-memory'
+
+/** @typedef {{ constrainedMemory?: () => unknown, totalmem?: () => unknown }} MemorySources */
+
+/**
+ * @param {string[]} args
+ * @param {string} flag
+ */
+export function hasNodeFlag(args, flag) {
+  return args.some(arg => arg === flag || arg.startsWith(`${flag}=`))
+}
+
+/**
+ * @param {string | undefined} nodeOptions
+ */
+export function nodeOptionArgs(nodeOptions) {
+  return (nodeOptions || '').split(/\s+/).filter(Boolean)
+}
+
+/**
+ * @param {string[]} args
+ */
+export function hasHeapLimitFlag(args) {
+  return hasNodeFlag(args, HEAP_SIZE_FLAG) || hasNodeFlag(args, HEAP_PERCENTAGE_FLAG)
+}
+
+/**
+ * @param {unknown} raw
+ * @returns {number | null}
+ */
+export function parsePositiveIntegerMb(raw) {
+  if (raw == null || raw === '') return null
+  const parsed = Number.parseInt(String(raw), 10)
+  return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : null
+}
+
+/**
+ * Node accepts a number greater than 0 and up to 100.
+ * @param {unknown} raw
+ * @returns {number | null}
+ */
+export function parsePercentage(raw) {
+  if (raw == null) return null
+  const trimmed = String(raw).trim()
+  if (!trimmed) return null
+  const withoutPercent = trimmed.endsWith('%') ? trimmed.slice(0, -1) : trimmed
+  if (withoutPercent.trim() === '') return null
+  const parsed = Number(withoutPercent)
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 100) return null
+  return parsed
+}
+
+/**
+ * Prefer cgroup/OS memory constraints so container limits win over host RAM.
+ * @param {MemorySources} [sources]
+ */
+export function getAvailableMemoryBytes(sources = {}) {
+  const constrainedMemory =
+    sources.constrainedMemory ??
+    (() => {
+      try {
+        return typeof process.constrainedMemory === 'function'
+          ? process.constrainedMemory()
+          : undefined
+      } catch {
+        return undefined
+      }
+    })
+  const totalmem = sources.totalmem ?? (() => os.totalmem())
+
+  const constrained = constrainedMemory()
+  // Node/libuv reports UINT64_MAX (not a safe integer in JS) when there is no
+  // cgroup/OS memory limit. Treat only real byte caps as constraints.
+  if (typeof constrained === 'number' && Number.isSafeInteger(constrained) && constrained > 0) {
+    return constrained
+  }
+  const total = totalmem()
+  if (typeof total === 'number' && Number.isFinite(total) && total > 0) {
+    return total
+  }
+  return 0
+}
+
+/**
+ * @param {number} percentage
+ * @param {number} availableBytes
+ * @returns {number | null}
+ */
+export function heapSizeMbFromPercentage(percentage, availableBytes) {
+  if (!(percentage > 0 && percentage <= 100) || !(availableBytes > 0)) return null
+  const mb = Math.floor((availableBytes * (percentage / 100)) / (1024 * 1024))
+  return Math.max(1, mb)
+}
+
+/**
+ * @param {string[]} args
+ * @param {string} flag
+ * @returns {string | null}
+ */
+export function findEqualsFlagValue(args, flag) {
+  const prefix = `${flag}=`
+  for (const arg of args) {
+    if (arg.startsWith(prefix)) return arg.slice(prefix.length)
+  }
+  return null
+}
+
+/**
+ * @param {string[]} args
+ * @param {string} flag
+ * @returns {string | null}
+ */
+export function findEqualsOrNextFlagValue(args, flag) {
+  const prefix = `${flag}=`
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg.startsWith(prefix)) return arg.slice(prefix.length)
+    if (arg === flag) {
+      const next = args[i + 1]
+      if (next && !next.startsWith('-')) return next
+      return ''
+    }
+  }
+  return null
+}
+
+/**
+ * Strip launcher-only heap args so Commander does not reject them.
+ * `--max-memory` stays equals-only to match the previous launcher contract.
+ * @param {string[]} args
+ */
+export function stripLauncherHeapArgs(args) {
+  const stripped = []
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    if (arg === MAX_MEMORY_FLAG || arg.startsWith(`${MAX_MEMORY_FLAG}=`)) continue
+    if (arg.startsWith(`${HEAP_PERCENTAGE_FLAG}=`)) continue
+    if (arg === HEAP_PERCENTAGE_FLAG) {
+      const next = args[i + 1]
+      if (next && !next.startsWith('-') && parsePercentage(next) != null) i += 1
+      continue
+    }
+    stripped.push(arg)
+  }
+  return stripped
+}
+
+/**
+ * @param {{
+ *   argv?: string[],
+ *   env?: NodeJS.ProcessEnv,
+ *   availableBytes?: number,
+ *   memorySources?: MemorySources,
+ * }} [input]
+ */
+export function resolveHeapSizeMb(input = {}) {
+  const argv = input.argv ?? []
+  const env = input.env ?? {}
+  const availableBytes =
+    input.availableBytes ?? getAvailableMemoryBytes(input.memorySources)
+
+  const maxMem = parsePositiveIntegerMb(findEqualsFlagValue(argv, MAX_MEMORY_FLAG))
+  if (maxMem != null) {
+    return { mb: maxMem, source: 'max-memory', setMaxMemoryEnv: true }
+  }
+
+  const argvPercentage = parsePercentage(
+    findEqualsOrNextFlagValue(argv, HEAP_PERCENTAGE_FLAG),
+  )
+  if (argvPercentage != null) {
+    const mb = heapSizeMbFromPercentage(argvPercentage, availableBytes)
+    if (mb != null) {
+      return { mb, source: 'argv-percentage', percentage: argvPercentage }
+    }
+    // Valid percentage requested; memory size unknown. Do not treat this as
+    // "no percentage" and fall through to an unrelated MB env value.
+    return {
+      mb: DEFAULT_HEAP_SIZE_MB,
+      source: 'percentage-unavailable',
+      percentage: argvPercentage,
+    }
+  }
+
+  const envPercentage = parsePercentage(env[HEAP_PERCENTAGE_ENV])
+  if (envPercentage != null) {
+    const mb = heapSizeMbFromPercentage(envPercentage, availableBytes)
+    if (mb != null) {
+      return { mb, source: 'env-percentage', percentage: envPercentage }
+    }
+    return {
+      mb: DEFAULT_HEAP_SIZE_MB,
+      source: 'percentage-unavailable',
+      percentage: envPercentage,
+    }
+  }
+
+  const envMb = parsePositiveIntegerMb(env[HEAP_SIZE_ENV])
+  if (envMb != null) return { mb: envMb, source: 'env-mb' }
+
+  return { mb: DEFAULT_HEAP_SIZE_MB, source: 'default' }
+}
+
+/**
+ * One-line operator warning when a valid percentage cannot be converted.
+ * @param {number} percentage
+ * @param {number} [fallbackMb]
+ */
+export function formatPercentageUnavailableStderr(
+  percentage,
+  fallbackMb = DEFAULT_HEAP_SIZE_MB,
+) {
+  return `openclaude: could not convert heap percentage ${percentage} to megabytes because available memory is unknown; using ${fallbackMb}`
+}

package/bin/import-specifier.mjs

@@ -0,0 +1,13 @@
+import { join, win32 } from 'path'
+import { pathToFileURL } from 'url'
+
+export function getDistImportSpecifier(baseDir) {
+  if (/^[A-Za-z]:\\/.test(baseDir)) {
+    const distPath = win32.join(baseDir, '..', 'dist', 'cli.mjs')
+    return `file:///${distPath.replace(/\\/g, '/')}`
+  }
+
+  const joinImpl = join
+  const distPath = joinImpl(baseDir, '..', 'dist', 'cli.mjs')
+  return pathToFileURL(distPath).href
+}

package/bin/import-specifier.test.mjs

@@ -0,0 +1,13 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { getDistImportSpecifier } from './import-specifier.mjs'
+
+test('builds a file URL import specifier for dist/cli.mjs', () => {
+  const specifier = getDistImportSpecifier('C:\\repo\\bin')
+
+  assert.equal(
+    specifier,
+    'file:///C:/repo/dist/cli.mjs',
+  )
+})

package/bin/node-compile-cache.mjs

@@ -0,0 +1,17 @@
+import * as nodeModule from 'node:module'
+
+/** @typedef {{ enableCompileCache?: () => unknown }} CompileCacheModule */
+
+/**
+ * @param {CompileCacheModule} [module=nodeModule]
+ */
+export function enableNodeCompileCacheIfAvailable(module = nodeModule) {
+  const enable = module.enableCompileCache
+  if (typeof enable !== 'function') return
+
+  try {
+    enable()
+  } catch {
+    // Compile caching is optional and must never block startup.
+  }
+}

package/bin/openclaude

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+
+/**
+ * OpenClaude — Claude Code with any LLM
+ *
+ * If dist/cli.mjs exists (built), run that.
+ * Otherwise, tell the user to build first or use `bun run dev`.
+ */
+
+import { existsSync } from 'fs'
+import { join, dirname } from 'path'
+import { fileURLToPath, pathToFileURL } from 'url'
+import { spawnSync } from 'child_process'
+import { enableNodeCompileCacheIfAvailable } from './node-compile-cache.mjs'
+import {
+  HEAP_SIZE_ENV,
+  HEAP_SIZE_FLAG,
+  formatPercentageUnavailableStderr,
+  hasHeapLimitFlag,
+  hasNodeFlag,
+  nodeOptionArgs,
+  resolveHeapSizeMb,
+  stripLauncherHeapArgs,
+} from './heap-limit.mjs'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const distPath = join(__dirname, '..', 'dist', 'cli.mjs')
+
+const HEAP_RELAUNCHED_ENV = 'OPENCLAUDE_HEAP_RELAUNCHED'
+const DISABLE_HEAP_RELAUNCH_ENV = 'OPENCLAUDE_DISABLE_HEAP_RELAUNCH'
+
+function currentNodeOptionArgs() {
+  return [...process.execArgv, ...nodeOptionArgs(process.env.NODE_OPTIONS)]
+}
+
+function applyResolvedHeapEnv(resolved) {
+  process.env[HEAP_SIZE_ENV] = String(resolved.mb)
+  if (resolved.setMaxMemoryEnv) {
+    process.env.OPENCLAUDE_MAX_MEMORY_MB = String(resolved.mb)
+  }
+}
+
+function replaceProcessArgvWithStrippedLauncherArgs() {
+  process.argv = [
+    process.argv[0],
+    process.argv[1],
+    ...stripLauncherHeapArgs(process.argv.slice(2)),
+  ]
+}
+
+function relaunchWithLongSessionHeapIfNeeded() {
+  if (process.env[DISABLE_HEAP_RELAUNCH_ENV] === '1') {
+    replaceProcessArgvWithStrippedLauncherArgs()
+    return
+  }
+  if (process.env[HEAP_RELAUNCHED_ENV] === '1') {
+    replaceProcessArgvWithStrippedLauncherArgs()
+    return
+  }
+  const nodeArgs = currentNodeOptionArgs()
+  const hasHeapLimit = hasHeapLimitFlag(nodeArgs)
+  const hasExplicitGc = hasNodeFlag(nodeArgs, '--expose-gc')
+  if (hasHeapLimit && hasExplicitGc) {
+    replaceProcessArgvWithStrippedLauncherArgs()
+    return
+  }
+
+  const execArgv = [...process.execArgv]
+  if (!hasHeapLimit) {
+    const resolved = resolveHeapSizeMb({
+      argv: process.argv.slice(2),
+      env: process.env,
+    })
+    if (resolved.source === 'percentage-unavailable') {
+      console.error(formatPercentageUnavailableStderr(resolved.percentage))
+    }
+    applyResolvedHeapEnv(resolved)
+    execArgv.push(`${HEAP_SIZE_FLAG}=${resolved.mb}`)
+  }
+
+  // Expose explicit GC for long interactive sessions. NODE_OPTIONS cannot
+  // carry --expose-gc, so the executable wrapper must add it before startup.
+  if (!hasExplicitGc) {
+    execArgv.push('--expose-gc')
+  }
+
+  // Strip launcher-only heap args before relaunching — Commander in the built
+  // CLI would reject them as unknown. The native Node percentage flag in
+  // execArgv/NODE_OPTIONS is left untouched because this process already
+  // started with a Node that accepted it.
+  const childArgs = stripLauncherHeapArgs(process.argv.slice(2))
+
+  // Preserve the original argv[1] (which may be a symlink like
+  // /usr/local/bin/openclaude) instead of resolving it via import.meta.url.
+  // Resolving symlinks here defeats install-type detection downstream: a real
+  // npm global install (symlink → node_modules/@twigpine/openclaude/bin) would
+  // resolve to the package's real path inside node_modules, which is fine, but
+  // a `npm install -g .` dev symlink resolves back to the repo and looks like
+  // a source-tree dev run. Using argv[1] keeps the invocation path stable so
+  // doctorDiagnostic's npm-global path markers can match correctly.
+  const launcherPath = process.argv[1] || fileURLToPath(import.meta.url)
+
+  const result = spawnSync(process.execPath, [
+    ...execArgv,
+    launcherPath,
+    ...childArgs,
+  ], {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      [HEAP_RELAUNCHED_ENV]: '1',
+    },
+  })
+
+  if (result.error) {
+    console.error(`openclaude: failed to restart with long-session heap: ${result.error.message}`)
+    process.exit(1)
+  }
+
+  process.exit(result.status ?? 1)
+}
+
+if (existsSync(distPath)) {
+  relaunchWithLongSessionHeapIfNeeded()
+  enableNodeCompileCacheIfAvailable()
+  await import(pathToFileURL(distPath).href)
+} else {
+  console.error(`
+  openclaude: dist/cli.mjs not found.
+
+  Build first:
+    bun run build
+
+  Or run directly with Bun:
+    bun run dev
+
+  See README.md for setup instructions.
+`)
+  process.exit(1)
+}