@swarmclawai/swarmclaw 0.9.9 → 1.0.2

package/bin/server-cmd.js

@@ -5,35 +5,37 @@
 const fs = require('node:fs')
 const path = require('node:path')
 const { spawn, execFileSync } = require('node:child_process')
-const os = require('node:os')
 const {
-  LOCKFILE_NAMES,
   detectPackageManager,
   getInstallCommand,
 } = require('./package-manager.js')
+const {
+  readPackageVersion,
+  resolvePackageRoot,
+  resolveStateHome,
+} = require('./install-root.js')
 
 // ---------------------------------------------------------------------------
 // Paths
 // ---------------------------------------------------------------------------
 
-const SWARMCLAW_HOME = process.env.SWARMCLAW_HOME || path.join(os.homedir(), '.swarmclaw')
-const PKG_ROOT = path.resolve(__dirname, '..')
-const BUILT_MARKER = path.join(SWARMCLAW_HOME, '.built')
+const PKG_ROOT = resolvePackageRoot({
+  moduleDir: __dirname,
+  argv1: process.argv[1],
+  cwd: process.cwd(),
+})
+const SWARMCLAW_HOME = resolveStateHome({
+  pkgRoot: PKG_ROOT,
+  moduleDir: __dirname,
+  argv1: process.argv[1],
+  cwd: process.cwd(),
+  env: process.env,
+})
 const PID_FILE = path.join(SWARMCLAW_HOME, 'server.pid')
 const LOG_FILE = path.join(SWARMCLAW_HOME, 'server.log')
 const DATA_DIR = path.join(SWARMCLAW_HOME, 'data')
-
-// Files/directories to copy from the npm package into SWARMCLAW_HOME
-const BUILD_COPY_ENTRIES = [
-  'src',
-  'public',
-  'scripts',
-  'next.config.ts',
-  'tsconfig.json',
-  'postcss.config.mjs',
-  'package.json',
-  ...LOCKFILE_NAMES,
-]
+const WORKSPACE_DIR = path.join(SWARMCLAW_HOME, 'workspace')
+const BROWSER_PROFILES_DIR = path.join(SWARMCLAW_HOME, 'browser-profiles')
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -69,116 +71,74 @@ function isProcessRunning(pid) {
   }
 }
 
-function copyPath(src, dest, { dereference = true } = {}) {
-  fs.rmSync(dest, { recursive: true, force: true })
-  fs.cpSync(src, dest, { recursive: true, dereference })
+function resolveStandaloneBase(pkgRoot = PKG_ROOT) {
+  return path.join(pkgRoot, '.next', 'standalone')
 }
 
-function symlinkPath(src, dest) {
-  fs.rmSync(dest, { recursive: true, force: true })
-  fs.symlinkSync(src, dest)
+function isGitCheckout(pkgRoot = PKG_ROOT) {
+  return fs.existsSync(path.join(pkgRoot, '.git'))
 }
 
-function readBuiltInfo() {
-  if (!fs.existsSync(BUILT_MARKER)) return null
-  try {
-    const raw = JSON.parse(fs.readFileSync(BUILT_MARKER, 'utf8'))
-    return raw && typeof raw === 'object' ? raw : null
-  } catch {
-    return null
-  }
+function getVersion() {
+  return readPackageVersion(PKG_ROOT) || 'unknown'
+}
+
+function ensurePackageDependencies(pkgRoot = PKG_ROOT) {
+  const nextCli = path.join(pkgRoot, 'node_modules', 'next', 'dist', 'bin', 'next')
+  if (fs.existsSync(nextCli)) return nextCli
+
+  const packageManager = detectPackageManager(pkgRoot, process.env)
+  const install = getInstallCommand(packageManager)
+  log(`Installing dependencies with ${packageManager}...`)
+  execFileSync(install.command, install.args, { cwd: pkgRoot, stdio: 'inherit' })
+  return nextCli
 }
 
 // ---------------------------------------------------------------------------
 // Build
 // ---------------------------------------------------------------------------
 
-function needsBuild(forceBuild) {
+function needsBuild(forceBuild, { pkgRoot = PKG_ROOT } = {}) {
   if (forceBuild) return true
-  const info = readBuiltInfo()
-  if (!info) return true
-  if (info.version !== getVersion()) return true
-  if (!findStandaloneServer()) return true
-  return false
+  return !findStandaloneServer({ pkgRoot })
 }
 
-function runBuild() {
+function runBuild({ pkgRoot = PKG_ROOT } = {}) {
   log('Preparing build environment...')
   ensureDir(SWARMCLAW_HOME)
   ensureDir(DATA_DIR)
 
-  // Copy source/config into SWARMCLAW_HOME. Turbopack build currently rejects
-  // app source symlinks that point outside the workspace root.
-  for (const entry of BUILD_COPY_ENTRIES) {
-    const src = path.join(PKG_ROOT, entry)
-    const dest = path.join(SWARMCLAW_HOME, entry)
-
-    if (!fs.existsSync(src)) {
-      log(`Warning: ${entry} not found in package, skipping`)
-      continue
-    }
-
-    copyPath(src, dest)
-  }
-
-  // Reuse package dependencies via symlink to avoid multi-GB duplication in
-  // SWARMCLAW_HOME. Build runs with webpack mode for symlink compatibility.
-  const nmSrc = path.join(PKG_ROOT, 'node_modules')
-  const nmDest = path.join(SWARMCLAW_HOME, 'node_modules')
-  if (fs.existsSync(nmSrc)) {
-    symlinkPath(nmSrc, nmDest)
-  } else {
-    // If node_modules doesn't exist at PKG_ROOT, install
-    const packageManager = detectPackageManager(SWARMCLAW_HOME, process.env)
-    const install = getInstallCommand(packageManager)
-    log(`Installing dependencies with ${packageManager}...`)
-    execFileSync(install.command, install.args, { cwd: SWARMCLAW_HOME, stdio: 'inherit' })
-  }
+  const nextCli = ensurePackageDependencies(pkgRoot)
 
-  // Run Next.js build
   log('Building Next.js application (this may take a minute)...')
-  const nextCli = path.join(SWARMCLAW_HOME, 'node_modules', 'next', 'dist', 'bin', 'next')
-  execFileSync(process.execPath, [nextCli, 'build'], {
-    cwd: SWARMCLAW_HOME,
+  execFileSync(process.execPath, [nextCli, 'build', '--webpack'], {
+    cwd: pkgRoot,
     stdio: 'inherit',
     env: {
       ...process.env,
+      SWARMCLAW_HOME,
+      DATA_DIR,
       SWARMCLAW_BUILD_MODE: '1',
     },
   })
 
-  // Write built marker
-  fs.writeFileSync(BUILT_MARKER, JSON.stringify({ builtAt: new Date().toISOString(), version: getVersion() }))
   log('Build complete.')
 }
 
-function getVersion() {
-  try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, 'package.json'), 'utf8'))
-    return pkg.version || 'unknown'
-  } catch {
-    return 'unknown'
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Find standalone server.js
 // ---------------------------------------------------------------------------
 
-function findStandaloneServer() {
-  // Next.js standalone output creates .next/standalone/ with server.js
-  // The path mirrors the build machine's directory structure
-  const standaloneBase = path.join(SWARMCLAW_HOME, '.next', 'standalone')
+function findStandaloneServer({ pkgRoot = PKG_ROOT } = {}) {
+  const standaloneBase = resolveStandaloneBase(pkgRoot)
 
   if (!fs.existsSync(standaloneBase)) {
     return null
   }
 
-  // Try direct server.js first
   const direct = path.join(standaloneBase, 'server.js')
   if (fs.existsSync(direct)) return direct
 
-  // Recursively search for server.js (handles nested paths from build machine)
   function search(dir) {
     const entries = fs.readdirSync(dir, { withFileTypes: true })
     for (const entry of entries) {
@@ -199,34 +159,42 @@ function findStandaloneServer() {
 // Start server
 // ---------------------------------------------------------------------------
 
-function startServer(opts) {
-  const serverJs = findStandaloneServer()
+function startServer(opts, { pkgRoot = PKG_ROOT } = {}) {
+  const serverJs = findStandaloneServer({ pkgRoot })
   if (!serverJs) {
-    logError('Standalone server.js not found. Try running: swarmclaw server --build')
+    logError('Standalone server.js not found in the installed package. Try running: swarmclaw server --build')
     process.exit(1)
   }
 
+  ensureDir(SWARMCLAW_HOME)
+  ensureDir(DATA_DIR)
+
   const port = opts.port || '3456'
   const wsPort = opts.wsPort || String(Number(port) + 1)
   const host = opts.host || '0.0.0.0'
 
   const env = {
     ...process.env,
+    SWARMCLAW_HOME,
+    DATA_DIR,
+    WORKSPACE_DIR,
+    BROWSER_PROFILES_DIR,
+    HOSTNAME: host,
     PORT: port,
     WS_PORT: wsPort,
-    HOSTNAME: host,
-    DATA_DIR,
   }
 
   log(`Starting server on ${host}:${port} (WebSocket: ${wsPort})...`)
+  log(`Package root: ${pkgRoot}`)
+  log(`Home: ${SWARMCLAW_HOME}`)
   log(`Data directory: ${DATA_DIR}`)
 
   if (opts.detach) {
-    // Detached mode — run in background
     const logStream = fs.openSync(LOG_FILE, 'a')
     const child = spawn(process.execPath, [serverJs], {
-      env,
+      cwd: pkgRoot,
       detached: true,
+      env,
       stdio: ['ignore', logStream, logStream],
     })
 
@@ -236,8 +204,8 @@ function startServer(opts) {
     log(`Logs: ${LOG_FILE}`)
     process.exit(0)
   } else {
-    // Foreground mode
     const child = spawn(process.execPath, [serverJs], {
+      cwd: pkgRoot,
       env,
       stdio: 'inherit',
     })
@@ -246,7 +214,6 @@ function startServer(opts) {
       process.exit(code || 0)
     })
 
-    // Forward signals
     for (const sig of ['SIGINT', 'SIGTERM']) {
       process.on(sig, () => child.kill(sig))
     }
@@ -288,27 +255,23 @@ function showStatus() {
   const pid = readPid()
   if (!pid) {
     log('Server: not running (no PID file)')
-    return
-  }
-
-  if (isProcessRunning(pid)) {
+  } else if (isProcessRunning(pid)) {
     log(`Server: running (PID: ${pid})`)
   } else {
     log(`Server: not running (stale PID: ${pid})`)
     try { fs.unlinkSync(PID_FILE) } catch {}
   }
 
+  log(`Package: ${PKG_ROOT}`)
   log(`Home: ${SWARMCLAW_HOME}`)
   log(`Data: ${DATA_DIR}`)
+  log(`Workspace: ${WORKSPACE_DIR}`)
+  log(`Browser profiles: ${BROWSER_PROFILES_DIR}`)
   log(`WebSocket port: ${process.env.WS_PORT || '(PORT + 1)'}`)
 
-  if (fs.existsSync(BUILT_MARKER)) {
-    try {
-      const info = JSON.parse(fs.readFileSync(BUILT_MARKER, 'utf8'))
-      log(`Built: ${info.builtAt || 'unknown'} (v${info.version || '?'})`)
-    } catch {
-      log('Built: yes')
-    }
+  const serverJs = findStandaloneServer()
+  if (serverJs) {
+    log(`Built: yes (${serverJs})`)
   } else {
     log('Built: no')
   }
@@ -338,8 +301,7 @@ Options:
   console.log(help)
 }
 
-function main() {
-  const args = process.argv.slice(3) // skip node, bin, 'server'
+function main(args = process.argv.slice(3)) {
   let command = 'start'
   let forceBuild = false
   let detach = false
@@ -385,9 +347,18 @@ function main() {
     return
   }
 
-  // command === 'start'
   if (needsBuild(forceBuild)) {
-    runBuild()
+    if (!forceBuild) {
+      const installKind = isGitCheckout() ? 'checkout' : 'installed package'
+      log(`Standalone server bundle not found in this ${installKind}. Building locally...`)
+    }
+    try {
+      runBuild()
+    } catch (err) {
+      logError(`Build failed: ${err.message}`)
+      logError('Retry manually with: swarmclaw server --build')
+      process.exit(1)
+    }
   }
 
   startServer({ port, wsPort, host, detach })
@@ -398,8 +369,16 @@ if (require.main === module) {
 }
 
 module.exports = {
+  DATA_DIR,
+  BROWSER_PROFILES_DIR,
+  PKG_ROOT,
+  SWARMCLAW_HOME,
+  WORKSPACE_DIR,
+  findStandaloneServer,
   getVersion,
+  isGitCheckout,
   main,
   needsBuild,
-  readBuiltInfo,
+  resolveStandaloneBase,
+  runBuild,
 }

package/bin/swarmclaw.js

@@ -96,6 +96,19 @@ function normalizeLegacyCliEnv(env) {
   return nextEnv
 }
 
+function printPackageVersion() {
+  const pkg = require('../package.json')
+  process.stdout.write(`${pkg.name || 'swarmclaw'} ${pkg.version || '0.0.0'}\n`)
+}
+
+function printVersionHelp() {
+  process.stdout.write(`
+Usage: swarmclaw version
+
+Show the installed SwarmClaw package version.
+`.trim() + '\n')
+}
+
 async function runMappedCli(argv) {
   const cliPath = path.join(__dirname, '..', 'src', 'cli', 'index.js')
   const cliModule = await import(cliPath)
@@ -106,25 +119,91 @@ async function runMappedCli(argv) {
   return runCli(argv)
 }
 
+async function runHelp(argv) {
+  const [target, ...rest] = argv
+  if (!target) {
+    const code = await runMappedCli(['--help'])
+    process.exitCode = typeof code === 'number' ? code : 1
+    return
+  }
+
+  if (target === 'run' || target === 'start' || target === 'stop' || target === 'status' || target === 'server') {
+    require('./server-cmd.js').main(['--help'])
+    return
+  }
+  if (target === 'worker') {
+    require('./worker-cmd.js').main(['--help'])
+    return
+  }
+  if (target === 'doctor') {
+    require('./doctor-cmd.js').main(['--help'])
+    return
+  }
+  if (target === 'update') {
+    require('./update-cmd.js').main(['--help'])
+    return
+  }
+  if (target === 'version') {
+    printVersionHelp()
+    return
+  }
+
+  const forwarded = rest.includes('--help') || rest.includes('-h')
+    ? [target, ...rest]
+    : [target, ...rest, '--help']
+  const code = shouldUseLegacyTsCli(forwarded)
+    ? runLegacyTsCli(forwarded)
+    : await runMappedCli(forwarded)
+
+  process.exitCode = typeof code === 'number' ? code : 1
+}
+
 async function main() {
   const argv = process.argv.slice(2)
   const top = argv[0]
 
   // Default to 'server' when invoked with no arguments.
   if (!top) {
-    require('./server-cmd.js').main()
+    require('./server-cmd.js').main([])
+    return
+  }
+
+  if (top === '-v') {
+    printPackageVersion()
+    return
+  }
+
+  if (top === 'version' && argv.length === 1) {
+    printPackageVersion()
     return
   }
 
-  // Route 'server', 'worker', and 'update' subcommands to CJS scripts (no TS dependency).
+  if (top === 'help') {
+    await runHelp(argv.slice(1))
+    return
+  }
+
+  // Route local lifecycle/maintenance commands to CJS scripts (no TS dependency).
   if (top === 'server') {
-    require('./server-cmd.js').main()
+    require('./server-cmd.js').main(argv.slice(1))
+    return
+  }
+  if (top === 'run' || top === 'start') {
+    require('./server-cmd.js').main(argv.slice(1))
+    return
+  }
+  if (top === 'status' || top === 'stop') {
+    require('./server-cmd.js').main([top, ...argv.slice(1)])
     return
   }
   if (top === 'worker') {
     require('./worker-cmd.js').main()
     return
   }
+  if (top === 'doctor') {
+    require('./doctor-cmd.js').main(argv.slice(1))
+    return
+  }
   if (top === 'update') {
     require('./update-cmd.js').main()
     return
@@ -146,6 +225,7 @@ module.exports = {
   hasTsxRuntime,
   TS_CLI_ACTIONS,
   normalizeLegacyCliEnv,
+  printPackageVersion,
   supportsStripTypes,
   shouldUseLegacyTsCli,
 }

package/bin/update-cmd.js

@@ -10,11 +10,19 @@ const {
   getGlobalUpdateSpec,
   getInstallCommand,
 } = require('./package-manager.js')
-
-const PKG_ROOT = path.resolve(__dirname, '..')
-const PACKAGE_NAME = '@swarmclawai/swarmclaw'
+const {
+  PACKAGE_NAME,
+  detectGlobalInstallManagerForRoot,
+  resolvePackageRoot,
+} = require('./install-root.js')
+
+const PKG_ROOT = resolvePackageRoot({
+  moduleDir: __dirname,
+  argv1: process.argv[1],
+  cwd: process.cwd(),
+})
 const RELEASE_TAG_RE = /^v\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/
-const PACKAGE_MANAGER = detectPackageManager(PKG_ROOT)
+const FALLBACK_PACKAGE_MANAGER = detectPackageManager(PKG_ROOT)
 
 function run(cmd) {
   return execSync(cmd, { encoding: 'utf-8', cwd: PKG_ROOT, timeout: 60_000 }).trim()
@@ -36,6 +44,12 @@ function getLatestStableTag() {
   return tags.find((t) => RELEASE_TAG_RE.test(t)) || null
 }
 
+function resolveRegistryPackageManager(execImpl = execFileSync) {
+  return detectGlobalInstallManagerForRoot(PKG_ROOT, execImpl, process.env)
+    || detectPackageManager(PKG_ROOT, process.env)
+    || FALLBACK_PACKAGE_MANAGER
+}
+
 function rebuildStandaloneServer(
   execImpl = execFileSync,
   logger = { log, logError },
@@ -58,10 +72,9 @@ function rebuildStandaloneServer(
 }
 
 function runRegistrySelfUpdate(
-  packageManager = PACKAGE_MANAGER,
+  packageManager = resolveRegistryPackageManager(),
   execImpl = execFileSync,
   logger = { log, logError },
-  rebuildImpl = execFileSync,
 ) {
   const update = getGlobalUpdateSpec(packageManager, PACKAGE_NAME)
   logger.log(`No git checkout detected. Updating the global ${PACKAGE_NAME} install via ${packageManager}...`)
@@ -78,30 +91,25 @@ function runRegistrySelfUpdate(
     return 1
   }
 
-  const rebuildExitCode = rebuildStandaloneServer(rebuildImpl, logger)
-  if (rebuildExitCode !== 0) return rebuildExitCode
-
   logger.log('Restart the server to apply changes: swarmclaw server stop && swarmclaw server start')
   return 0
 }
 
-function main() {
-  const args = process.argv.slice(3)
+function main(args = process.argv.slice(3)) {
   if (args.includes('-h') || args.includes('--help')) {
     console.log(`
 Usage: swarmclaw update
 
 If running from a git checkout, pull the latest SwarmClaw release tag.
-If running from a registry install, update the global package with ${PACKAGE_MANAGER}.
+If running from a registry install, update the global package with its owning package manager.
 `.trim())
     process.exit(0)
   }
 
-  // Verify we're in a git repo
   try {
     run('git rev-parse --git-dir')
   } catch {
-    process.exit(runRegistrySelfUpdate(PACKAGE_MANAGER))
+    process.exit(runRegistrySelfUpdate())
   }
 
   const beforeRef = run('git rev-parse HEAD')
@@ -127,7 +135,6 @@ If running from a registry install, update the global package with ${PACKAGE_MAN
       process.exit(0)
     }
 
-    // Check for uncommitted changes
     const dirty = run('git status --porcelain')
     if (dirty) {
       logError('Local changes detected. Commit or stash them first, then retry.')
@@ -138,7 +145,6 @@ If running from a registry install, update the global package with ${PACKAGE_MAN
     run(`git checkout -B stable ${latestTag}^{commit}`)
     pullOutput = `Updated to stable release ${latestTag}.`
   } else {
-    // Fallback: pull from origin/main
     const behindCount = parseInt(run('git rev-list HEAD..origin/main --count'), 10) || 0
     if (behindCount === 0) {
       log(`Already up to date (${beforeSha}).`)
@@ -158,16 +164,21 @@ If running from a registry install, update the global package with ${PACKAGE_MAN
   const newSha = run('git rev-parse --short HEAD')
   log(pullOutput)
 
-  // Install deps if package files changed
   try {
     const diff = run(`git diff --name-only ${beforeSha}..HEAD`)
     if (dependenciesChanged(diff)) {
-      const install = getInstallCommand(PACKAGE_MANAGER, true)
-      log(`Package files changed — running ${PACKAGE_MANAGER} install...`)
+      const packageManager = detectPackageManager(PKG_ROOT, process.env)
+      const install = getInstallCommand(packageManager, true)
+      log(`Package files changed — running ${packageManager} install...`)
       execFileSync(install.command, install.args, { cwd: PKG_ROOT, stdio: 'inherit', timeout: 120_000 })
     }
   } catch {
-    // If diff fails, skip install check
+    // If diff fails, skip install check.
+  }
+
+  const rebuildExitCode = rebuildStandaloneServer()
+  if (rebuildExitCode !== 0) {
+    process.exit(rebuildExitCode)
   }
 
   log(`Done (${beforeSha} → ${newSha}, channel: ${channel}).`)
@@ -180,5 +191,7 @@ if (require.main === module) {
 
 module.exports = {
   main,
+  rebuildStandaloneServer,
+  resolveRegistryPackageManager,
   runRegistrySelfUpdate,
 }

package/bin/update-cmd.test.js

@@ -3,11 +3,10 @@
 
 const test = require('node:test')
 const assert = require('node:assert/strict')
-const path = require('node:path')
 
 const { runRegistrySelfUpdate } = require('./update-cmd.js')
 
-test('runRegistrySelfUpdate executes the manager-specific global update command and rebuilds the standalone server', () => {
+test('runRegistrySelfUpdate executes the manager-specific global update command', () => {
   const messages = []
   const captured = []
 
@@ -20,9 +19,6 @@ test('runRegistrySelfUpdate executes the manager-specific global update command
       log: (message) => messages.push(`log:${message}`),
       logError: (message) => messages.push(`err:${message}`),
     },
-    (command, args, options) => {
-      captured.push({ command, args, options })
-    },
   )
 
   assert.equal(exitCode, 0)
@@ -36,20 +32,9 @@ test('runRegistrySelfUpdate executes the manager-specific global update command
         timeout: 120_000,
       },
     },
-    {
-      command: process.execPath,
-      args: [path.join(process.cwd(), 'bin', 'server-cmd.js'), '--build'],
-      options: {
-        cwd: process.cwd(),
-        stdio: 'inherit',
-        timeout: 600_000,
-      },
-    },
   ])
   assert.match(messages.join('\n'), /updating the global @swarmclawai\/swarmclaw install via pnpm/i)
   assert.match(messages.join('\n'), /global update complete via pnpm/i)
-  assert.match(messages.join('\n'), /rebuilding the standalone server bundle/i)
-  assert.match(messages.join('\n'), /standalone server bundle rebuilt/i)
 })
 
 test('runRegistrySelfUpdate reports a manual retry command when the registry update fails', () => {
@@ -70,23 +55,3 @@ test('runRegistrySelfUpdate reports a manual retry command when the registry upd
   assert.match(messages.join('\n'), /registry update failed: spawn bun ENOENT/i)
   assert.match(messages.join('\n'), /retry manually with: bun add -g @swarmclawai\/swarmclaw@latest/i)
 })
-
-test('runRegistrySelfUpdate reports a manual rebuild command when the rebuild step fails', () => {
-  const messages = []
-
-  const exitCode = runRegistrySelfUpdate(
-    'npm',
-    () => {},
-    {
-      log: (message) => messages.push(`log:${message}`),
-      logError: (message) => messages.push(`err:${message}`),
-    },
-    () => {
-      throw new Error('build failed')
-    },
-  )
-
-  assert.equal(exitCode, 1)
-  assert.match(messages.join('\n'), /standalone rebuild failed: build failed/i)
-  assert.match(messages.join('\n'), /retry manually with: swarmclaw server --build/i)
-})