@swarmclawai/swarmclaw 0.9.9 → 1.0.0

package/bin/install-root.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+'use strict'
+
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const { execFileSync } = require('node:child_process')
+
+const PACKAGE_NAME = '@swarmclawai/swarmclaw'
+const CORE_PACKAGE_NAMES = new Set([PACKAGE_NAME])
+
+function normalizeDir(value) {
+  if (!value) return null
+  const trimmed = String(value).trim()
+  if (!trimmed) return null
+  return path.resolve(trimmed)
+}
+
+function readPackageJson(rootDir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(rootDir, 'package.json'), 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+function readPackageName(rootDir) {
+  return readPackageJson(rootDir)?.name?.trim() || null
+}
+
+function readPackageVersion(rootDir) {
+  const version = readPackageJson(rootDir)?.version
+  return typeof version === 'string' && version.trim() ? version.trim() : null
+}
+
+function* iterAncestorDirs(startDir, maxDepth = 12) {
+  let current = path.resolve(startDir)
+  for (let i = 0; i < maxDepth; i += 1) {
+    yield current
+    const parent = path.dirname(current)
+    if (parent === current) break
+    current = parent
+  }
+}
+
+function findPackageRoot(startDir, maxDepth = 12) {
+  for (const current of iterAncestorDirs(startDir, maxDepth)) {
+    const name = readPackageName(current)
+    if (name && CORE_PACKAGE_NAMES.has(name)) return current
+  }
+  return null
+}
+
+function candidateDirsFromArgv1(argv1) {
+  const normalized = normalizeDir(argv1)
+  if (!normalized) return []
+
+  const candidates = [path.dirname(normalized)]
+  try {
+    const resolved = fs.realpathSync(normalized)
+    if (resolved !== normalized) candidates.push(path.dirname(resolved))
+  } catch {}
+
+  const parts = normalized.split(path.sep)
+  const binIndex = parts.lastIndexOf('.bin')
+  if (binIndex > 0 && parts[binIndex - 1] === 'node_modules') {
+    const binName = path.basename(normalized)
+    const nodeModulesDir = parts.slice(0, binIndex).join(path.sep)
+    candidates.push(path.join(nodeModulesDir, binName))
+  }
+
+  return candidates
+}
+
+function resolvePackageRoot(opts = {}) {
+  const candidates = []
+  const moduleDir = normalizeDir(opts.moduleDir)
+  if (moduleDir) candidates.push(moduleDir)
+  const argv1 = opts.argv1 === undefined ? process.argv[1] : opts.argv1
+  candidates.push(...candidateDirsFromArgv1(argv1))
+  const cwd = opts.cwd === undefined ? process.cwd() : opts.cwd
+  if (normalizeDir(cwd)) candidates.push(path.resolve(cwd))
+
+  for (const candidate of candidates) {
+    const found = findPackageRoot(candidate)
+    if (found) return found
+  }
+
+  return moduleDir ? path.resolve(moduleDir, '..') : null
+}
+
+function tryRealpath(targetPath) {
+  try {
+    return fs.realpathSync(targetPath)
+  } catch {
+    return path.resolve(targetPath)
+  }
+}
+
+function runRootCommand(command, args, execImpl = execFileSync) {
+  try {
+    return String(execImpl(command, args, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })).trim()
+  } catch {
+    return null
+  }
+}
+
+function resolveGlobalRoot(manager, execImpl = execFileSync, env = process.env) {
+  if (manager === 'bun') {
+    const bunInstall = String(env.BUN_INSTALL || '').trim() || path.join(os.homedir(), '.bun')
+    return path.join(bunInstall, 'install', 'global', 'node_modules')
+  }
+
+  if (manager === 'pnpm') {
+    return runRootCommand('pnpm', ['root', '-g'], execImpl)
+  }
+
+  return runRootCommand('npm', ['root', '-g'], execImpl)
+}
+
+function detectGlobalInstallManagerForRoot(pkgRoot, execImpl = execFileSync, env = process.env) {
+  const pkgReal = tryRealpath(pkgRoot)
+
+  for (const manager of ['npm', 'pnpm']) {
+    const globalRoot = resolveGlobalRoot(manager, execImpl, env)
+    if (!globalRoot) continue
+
+    for (const name of CORE_PACKAGE_NAMES) {
+      const expectedReal = tryRealpath(path.join(globalRoot, name))
+      if (path.resolve(expectedReal) === path.resolve(pkgReal)) return manager
+    }
+  }
+
+  const bunRoot = resolveGlobalRoot('bun', execImpl, env)
+  for (const name of CORE_PACKAGE_NAMES) {
+    const expectedReal = tryRealpath(path.join(bunRoot, name))
+    if (path.resolve(expectedReal) === path.resolve(pkgReal)) return 'bun'
+  }
+
+  return null
+}
+
+module.exports = {
+  PACKAGE_NAME,
+  candidateDirsFromArgv1,
+  detectGlobalInstallManagerForRoot,
+  findPackageRoot,
+  readPackageName,
+  readPackageVersion,
+  resolveGlobalRoot,
+  resolvePackageRoot,
+}

package/bin/install-root.test.js

@@ -0,0 +1,61 @@
+'use strict'
+/* eslint-disable @typescript-eslint/no-require-imports */
+
+const test = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+
+const {
+  candidateDirsFromArgv1,
+  detectGlobalInstallManagerForRoot,
+  resolvePackageRoot,
+} = require('./install-root.js')
+
+test('candidateDirsFromArgv1 includes the package directory for node_modules/.bin launchers', () => {
+  const launcher = path.join('/tmp', 'example', 'node_modules', '.bin', 'swarmclaw')
+  const candidates = candidateDirsFromArgv1(launcher)
+  assert.deepEqual(candidates, [
+    path.join('/tmp', 'example', 'node_modules', '.bin'),
+    path.join('/tmp', 'example', 'node_modules', 'swarmclaw'),
+  ])
+})
+
+test('resolvePackageRoot finds the package root from argv1 candidates', () => {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-install-root-'))
+  const pkgRoot = path.join(rootDir, 'node_modules', '@swarmclawai', 'swarmclaw')
+  const binPath = path.join(rootDir, 'node_modules', '.bin', 'swarmclaw')
+  const actualBin = path.join(pkgRoot, 'bin', 'swarmclaw.js')
+
+  fs.mkdirSync(path.join(pkgRoot, 'bin'), { recursive: true })
+  fs.mkdirSync(path.dirname(binPath), { recursive: true })
+  fs.writeFileSync(path.join(pkgRoot, 'package.json'), JSON.stringify({ name: '@swarmclawai/swarmclaw' }), 'utf8')
+  fs.writeFileSync(actualBin, '#!/usr/bin/env node\n', 'utf8')
+  fs.symlinkSync(actualBin, binPath)
+
+  assert.equal(resolvePackageRoot({ argv1: binPath, cwd: rootDir }), fs.realpathSync(pkgRoot))
+
+  fs.rmSync(rootDir, { recursive: true, force: true })
+})
+
+test('detectGlobalInstallManagerForRoot matches the owning global root by realpath', () => {
+  const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-global-root-'))
+  const npmGlobalRoot = path.join(rootDir, 'npm-global')
+  const pnpmGlobalRoot = path.join(rootDir, 'pnpm-global')
+  const pkgRoot = path.join(pnpmGlobalRoot, '@swarmclawai', 'swarmclaw')
+
+  fs.mkdirSync(path.join(npmGlobalRoot, '@swarmclawai'), { recursive: true })
+  fs.mkdirSync(path.join(pnpmGlobalRoot, '@swarmclawai'), { recursive: true })
+  fs.mkdirSync(pkgRoot, { recursive: true })
+
+  const execImpl = (command, args) => {
+    if (command === 'npm' && args.join(' ') === 'root -g') return npmGlobalRoot
+    if (command === 'pnpm' && args.join(' ') === 'root -g') return pnpmGlobalRoot
+    throw new Error(`unexpected command: ${command} ${args.join(' ')}`)
+  }
+
+  assert.equal(detectGlobalInstallManagerForRoot(pkgRoot, execImpl), 'pnpm')
+
+  fs.rmSync(rootDir, { recursive: true, force: true })
+})

package/bin/server-cmd.js

@@ -7,34 +7,28 @@ 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,
+} = 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 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,
-]
-
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -69,116 +63,69 @@ 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 getVersion() {
+  return readPackageVersion(PKG_ROOT) || 'unknown'
 }
 
-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 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)
-  }
+  const nextCli = ensurePackageDependencies(pkgRoot)
 
-  // 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' })
-  }
-
-  // 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,
+    cwd: pkgRoot,
     stdio: 'inherit',
     env: {
       ...process.env,
+      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 +146,38 @@ 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,
+    DATA_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(`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 +187,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 +197,6 @@ function startServer(opts) {
       process.exit(code || 0)
     })
 
-    // Forward signals
     for (const sig of ['SIGINT', 'SIGTERM']) {
       process.on(sig, () => child.kill(sig))
     }
@@ -288,27 +238,21 @@ 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(`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')
   }
@@ -339,7 +283,7 @@ Options:
 }
 
 function main() {
-  const args = process.argv.slice(3) // skip node, bin, 'server'
+  const args = process.argv.slice(3)
   let command = 'start'
   let forceBuild = false
   let detach = false
@@ -385,7 +329,6 @@ function main() {
     return
   }
 
-  // command === 'start'
   if (needsBuild(forceBuild)) {
     runBuild()
   }
@@ -398,8 +341,13 @@ if (require.main === module) {
 }
 
 module.exports = {
+  DATA_DIR,
+  PKG_ROOT,
+  SWARMCLAW_HOME,
+  findStandaloneServer,
   getVersion,
   main,
   needsBuild,
-  readBuiltInfo,
+  resolveStandaloneBase,
+  runBuild,
 }

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,7 +72,7 @@ function rebuildStandaloneServer(
 }
 
 function runRegistrySelfUpdate(
-  packageManager = PACKAGE_MANAGER,
+  packageManager = resolveRegistryPackageManager(),
   execImpl = execFileSync,
   logger = { log, logError },
   rebuildImpl = execFileSync,
@@ -92,16 +106,15 @@ function main() {
 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 +140,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 +150,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 +169,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 +196,7 @@ if (require.main === module) {
 
 module.exports = {
   main,
+  rebuildStandaloneServer,
+  resolveRegistryPackageManager,
   runRegistrySelfUpdate,
 }

package/bin/worker-cmd.js

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 'use strict'
 
-const fs = require('node:fs')
-const path = require('node:path')
-const os = require('node:os')
 const { spawn } = require('node:child_process')
 
+const {
+  DATA_DIR,
+  PKG_ROOT,
+  SWARMCLAW_HOME,
+  findStandaloneServer,
+} = require('./server-cmd.js')
+
 function printHelp() {
   const help = `
 Usage: swarmclaw worker [options]
@@ -32,27 +36,23 @@ function main() {
     }
   }
 
-  const SWARMCLAW_HOME = process.env.SWARMCLAW_HOME || path.join(os.homedir(), '.swarmclaw')
-  const DATA_DIR = path.join(SWARMCLAW_HOME, 'data')
-
   process.env.DATA_DIR = DATA_DIR
   process.env.SWARMCLAW_DAEMON_BACKGROUND_SERVICES = '1'
-  // Flag that tells Next.js NOT to start the HTTP/Websocket listener, just boot the daemon.
   process.env.SWARMCLAW_WORKER_ONLY = '1'
 
-  console.log(`[swarmclaw] Starting dedicated background worker...`)
+  console.log('[swarmclaw] Starting dedicated background worker...')
+  console.log(`[swarmclaw] Package root: ${PKG_ROOT}`)
+  console.log(`[swarmclaw] Home: ${SWARMCLAW_HOME}`)
   console.log(`[swarmclaw] Data directory: ${DATA_DIR}`)
 
-  // We reuse the built server.js but signal it to only run the daemon
-  const standaloneBase = path.join(SWARMCLAW_HOME, '.next', 'standalone')
-  let serverJs = path.join(standaloneBase, 'server.js')
-  
-  if (!fs.existsSync(serverJs)) {
-     console.error('Standalone server.js not found. Try running: swarmclaw server --build')
-     process.exit(1)
+  const serverJs = findStandaloneServer()
+  if (!serverJs) {
+    console.error('[swarmclaw] Standalone server.js not found in the installed package. Try running: swarmclaw server --build')
+    process.exit(1)
   }
 
   const child = spawn(process.execPath, [serverJs], {
+    cwd: PKG_ROOT,
     env: process.env,
     stdio: 'inherit',
   })