theslopmachine 0.3.7 → 0.4.0

package/src/install.js

@@ -3,7 +3,7 @@ import os from 'node:os'
 import path from 'node:path'
 
 import {
-  BEADS_VERSION,
+  BR_VERSION,
   buildPaths,
   MCP_ENTRIES,
   OPCODE_VERSION,
@@ -14,8 +14,8 @@ import {
 import {
   backupFile,
   commandExists,
-  copyDirIfMissing,
-  copyFileIfMissing,
+  copyDirReplacing,
+  copyFileReplacing,
   ensureDir,
   findBashExecutable,
   getGlobalNpmPackageVersion,
@@ -28,6 +28,7 @@ import {
   readJsonIfExists,
   resolveCommand,
   runCommand,
+  section,
   warn,
   writeJson,
 } from './utils.js'
@@ -44,26 +45,21 @@ function getUnixBeadsBinDirs() {
   const home = getHomeDir()
   return [
     path.join(home, '.local', 'bin'),
-    path.join(home, 'go', 'bin'),
-    path.join(home, '.linuxbrew', 'bin'),
+    path.join(home, '.cargo', 'bin'),
     '/opt/homebrew/bin',
     '/usr/local/bin',
-    '/home/linuxbrew/.linuxbrew/bin',
   ]
 }
 
-function getLinuxBeadsBinDir() {
-  return path.join(getHomeDir(), '.local', 'bin')
-}
-
 function getWindowsBeadsBinDirs() {
   if (process.platform !== 'win32') {
     return []
   }
 
   const dirs = [
-    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Programs', 'bd') : null,
-    process.env.USERPROFILE ? path.join(process.env.USERPROFILE, 'go', 'bin') : null,
+    process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, 'Programs', 'br') : null,
+    path.join(getHomeDir(), '.local', 'bin'),
+    path.join(getHomeDir(), '.cargo', 'bin'),
   ].filter(Boolean)
 
   return [...new Set(dirs)]
@@ -71,14 +67,14 @@ function getWindowsBeadsBinDirs() {
 
 function getBeadsCommandCandidates() {
   if (process.platform === 'win32') {
-    return getWindowsBeadsBinDirs().map((dir) => path.join(dir, 'bd.exe'))
+    return getWindowsBeadsBinDirs().map((dir) => path.join(dir, 'br.exe'))
   }
 
-  return getUnixBeadsBinDirs().map((dir) => path.join(dir, 'bd'))
+  return getUnixBeadsBinDirs().map((dir) => path.join(dir, 'br'))
 }
 
 async function resolveBeadsCommand() {
-  return resolveCommand('bd', { additionalCandidates: getBeadsCommandCandidates(), preferCandidates: true })
+  return resolveCommand('br', { additionalCandidates: getBeadsCommandCandidates(), preferCandidates: true })
 }
 
 async function getBeadsVersion() {
@@ -99,14 +95,24 @@ async function probeBeadsRuntime(command) {
   const probeDir = await fs.mkdtemp(path.join(os.tmpdir(), 'slopmachine-beads-probe-'))
 
   try {
-    const result = await runCommand(command, ['init', '--quiet', '--stealth', '--skip-hooks'], {
+    const result = await runCommand(command, ['init', '--quiet'], {
       cwd: probeDir,
       env: { ...process.env, CI: '1' },
     })
 
-    const output = `${result.stdout}${result.stderr}`.trim()
+    if (result.code !== 0) {
+      const output = `${result.stdout}${result.stderr}`.trim()
+      return { ok: false, output }
+    }
+
+    const syncResult = await runCommand(command, ['sync', '--flush-only'], {
+      cwd: probeDir,
+      env: { ...process.env, CI: '1' },
+    })
+
+    const output = `${syncResult.stdout}${syncResult.stderr}`.trim()
     return {
-      ok: result.code === 0,
+      ok: syncResult.code === 0,
       output,
     }
   } finally {
@@ -167,7 +173,7 @@ async function ensureUnixBeadsPath() {
   }
 
   for (const dir of getUnixBeadsBinDirs()) {
-    if (!(await pathExists(path.join(dir, 'bd')))) {
+    if (!(await pathExists(path.join(dir, 'br')))) {
       continue
     }
 
@@ -175,122 +181,120 @@ async function ensureUnixBeadsPath() {
   }
 }
 
-async function installLinuxBeadsPrerequisites() {
-  const managers = await detectPackageManagers()
-
-  if (managers.apt) {
-    log('Installing Linux Beads build dependencies via apt')
-    const updateResult = await runCommand('sudo', ['apt-get', 'update'], { stdio: 'inherit' })
-    if (updateResult.code !== 0) {
-      return updateResult
-    }
-
-    return runCommand('sudo', [
-      'apt-get',
-      'install',
-      '-y',
-      'build-essential',
-      'pkg-config',
-      'libicu-dev',
-      'libzstd-dev',
-      'golang-go',
-    ], { stdio: 'inherit' })
-  }
-
-  if (managers.dnf) {
-    log('Installing Linux Beads build dependencies via dnf')
-    return runCommand('sudo', [
-      'dnf',
-      'install',
-      '-y',
-      'gcc',
-      'gcc-c++',
-      'make',
-      'pkgconf-pkg-config',
-      'libicu-devel',
-      'libzstd-devel',
-      'golang',
-    ], { stdio: 'inherit' })
-  }
-
-  return { code: 0, stdout: '', stderr: '' }
-}
-
 async function installBeadsOnWindows() {
   const shell = await resolveCommand('pwsh') || await resolveCommand('powershell')
   if (!shell) {
-    return { code: 1, stdout: '', stderr: 'PowerShell is required to install Beads on Windows' }
+    return { code: 1, stdout: '', stderr: 'PowerShell is required to install beads_rust on Windows' }
+  }
+
+  if (process.arch !== 'x64') {
+    return { code: 1, stdout: '', stderr: `Unsupported Windows architecture for beads_rust: ${process.arch}` }
   }
 
-  log('Installing Beads with the upstream Windows PowerShell installer')
-  const result = await runCommand(shell, [
-    '-NoProfile',
-    '-ExecutionPolicy',
-    'Bypass',
-    '-Command',
-    'irm https://raw.githubusercontent.com/steveyegge/beads/main/install.ps1 | iex',
-  ], { stdio: 'inherit' })
+  const installDir = process.env.LOCALAPPDATA
+    ? path.join(process.env.LOCALAPPDATA, 'Programs', 'br')
+    : path.join(getHomeDir(), 'AppData', 'Local', 'Programs', 'br')
 
+  const zipName = `br-v${BR_VERSION}-windows_amd64.zip`
+  const downloadUrl = `https://github.com/Dicklesworthstone/beads_rust/releases/download/v${BR_VERSION}/${zipName}`
+  const tempZip = process.env.TEMP
+    ? path.join(process.env.TEMP, zipName)
+    : path.join(getHomeDir(), 'AppData', 'Local', 'Temp', zipName)
+
+  const ps = [
+    '$ErrorActionPreference = "Stop"',
+    `$zipUrl = ${quotePowerShell(downloadUrl)}`,
+    `$zipPath = ${quotePowerShell(tempZip)}`,
+    `$installDir = ${quotePowerShell(installDir)}`,
+    'New-Item -ItemType Directory -Force -Path $installDir | Out-Null',
+    'Invoke-WebRequest -Uri $zipUrl -OutFile $zipPath',
+    'Expand-Archive -Path $zipPath -DestinationPath $installDir -Force',
+    'Remove-Item -Path $zipPath -Force -ErrorAction SilentlyContinue',
+  ].join('; ')
+
+  log(`Installing beads_rust ${BR_VERSION} on Windows from release zip`)
+  const result = await runCommand(shell, ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', ps], { stdio: 'inherit' })
   await ensureWindowsBeadsPath()
   return result
 }
 
-async function installBeadsOnUnix() {
-  if (process.platform === 'linux') {
-    const depsResult = await installLinuxBeadsPrerequisites()
-    if (depsResult.code !== 0) {
-      return depsResult
-    }
+function getLinuxBrFallbackArchiveName() {
+  if (process.platform !== 'linux') {
+    return null
+  }
 
-    if (!(await commandExists('go'))) {
-      return { code: 1, stdout: '', stderr: 'Go is required to build a CGO-enabled Beads binary on Linux' }
-    }
+  if (process.arch === 'x64') {
+    return `br-v${BR_VERSION}-linux_musl_amd64.tar.gz`
+  }
 
-    const binDir = getLinuxBeadsBinDir()
-    await ensureDir(binDir)
+  if (process.arch === 'arm64') {
+    return `br-v${BR_VERSION}-linux_arm64.tar.gz`
+  }
 
-    log(`Installing Beads ${BEADS_VERSION} on Linux with CGO_ENABLED=1`)
-    const result = await runCommand('go', ['install', `github.com/steveyegge/beads/cmd/bd@v${BEADS_VERSION}`], {
-      stdio: 'inherit',
-      env: {
-        ...process.env,
-        CGO_ENABLED: '1',
-        GOBIN: binDir,
-      },
-    })
+  return null
+}
 
-    await ensureUnixBeadsPath()
-    return result
+async function downloadFile(url, outputPath) {
+  const response = await fetch(url)
+  if (!response.ok) {
+    throw new Error(`Download failed with status ${response.status}`)
   }
 
-  const managers = await detectPackageManagers()
-  if (managers.brew) {
-    log('Installing Beads via Homebrew')
-    const result = await runCommand('brew', ['install', 'beads'], { stdio: 'inherit' })
+  const buffer = Buffer.from(await response.arrayBuffer())
+  await fs.writeFile(outputPath, buffer)
+}
+
+async function installLinuxBrFallbackBinary() {
+  const archiveName = getLinuxBrFallbackArchiveName()
+  if (!archiveName) {
+    return { code: 1, stdout: '', stderr: `Unsupported Linux architecture for beads_rust fallback: ${process.arch}` }
+  }
+
+  const downloadUrl = `https://github.com/Dicklesworthstone/beads_rust/releases/download/v${BR_VERSION}/${archiveName}`
+  const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'slopmachine-br-fallback-'))
+  const archivePath = path.join(tempDir, archiveName)
+  const binDir = path.join(getHomeDir(), '.local', 'bin')
+
+  try {
+    await ensureDir(binDir)
+    log(`Installing beads_rust fallback binary ${archiveName}`)
+    await downloadFile(downloadUrl, archivePath)
+
+    const extractResult = await runCommand('tar', ['-xzf', archivePath, '-C', tempDir])
+    if (extractResult.code !== 0) {
+      return extractResult
+    }
+
+    const sourceBinary = path.join(tempDir, 'br')
+    if (!(await pathExists(sourceBinary))) {
+      return { code: 1, stdout: '', stderr: 'Downloaded beads_rust archive did not contain br' }
+    }
+
+    await fs.copyFile(sourceBinary, path.join(binDir, 'br'))
+    await fs.chmod(path.join(binDir, 'br'), 0o755)
     await ensureUnixBeadsPath()
-    return result
+    return { code: 0, stdout: '', stderr: '' }
+  } catch (error) {
+    return { code: 1, stdout: '', stderr: error instanceof Error ? error.message : String(error) }
+  } finally {
+    await fs.rm(tempDir, { recursive: true, force: true })
   }
+}
 
+async function installBeadsOnUnix() {
   const bashExecutable = await findBashExecutable()
   if (!bashExecutable) {
-    return { code: 1, stdout: '', stderr: 'bash is required to run the Beads installer on this platform' }
+    return { code: 1, stdout: '', stderr: 'bash is required to run the beads_rust installer on this platform' }
   }
 
-  if (await commandExists('curl')) {
-    log('Installing Beads with the upstream Unix install script')
-    const result = await runCommand(bashExecutable, ['-lc', 'curl -fsSL https://raw.githubusercontent.com/steveyegge/beads/main/scripts/install.sh | bash'], { stdio: 'inherit' })
-    await ensureUnixBeadsPath()
-    return result
+  if (!(await commandExists('curl'))) {
+    return { code: 1, stdout: '', stderr: 'curl is required to install beads_rust automatically on this platform' }
   }
 
-  if (await commandExists('wget')) {
-    log('Installing Beads with the upstream Unix install script')
-    const result = await runCommand(bashExecutable, ['-lc', 'wget -qO- https://raw.githubusercontent.com/steveyegge/beads/main/scripts/install.sh | bash'], { stdio: 'inherit' })
-    await ensureUnixBeadsPath()
-    return result
-  }
-
-  return { code: 1, stdout: '', stderr: 'curl or wget is required to install Beads on this platform' }
+  log('Installing beads_rust with the upstream Unix install script')
+  const result = await runCommand(bashExecutable, ['-lc', 'curl -fsSL "https://raw.githubusercontent.com/Dicklesworthstone/beads_rust/main/install.sh?$(date +%s)" | bash'], { stdio: 'inherit' })
+  await ensureUnixBeadsPath()
+  return result
 }
 
 async function getCommandVersion(command, args = ['--version']) {
@@ -337,7 +341,7 @@ async function tryInstallCoreDependency(name) {
     log('Installing opencode-ai@latest globally via npm')
     return runCommand('npm', ['install', '-g', 'opencode-ai@latest'], { stdio: 'inherit' })
   }
-  if (name === 'bd') {
+  if (name === 'br') {
     if (process.platform === 'win32') {
       return installBeadsOnWindows()
     }
@@ -419,7 +423,7 @@ async function ensureDependency({ name, checkCommand, requiredVersion, installab
     }
   }
 
-  if (checkCommand === 'bd') {
+  if (checkCommand === 'br') {
     const beads = await getBeadsVersion()
     if (beads) {
       const probe = await probeBeadsRuntime(beads.command)
@@ -483,23 +487,59 @@ async function ensureDependency({ name, checkCommand, requiredVersion, installab
     warn('opencode-ai install completed, but the package could not be verified. Open a new terminal and run `opencode --version` before using `slopmachine init -o`.')
   }
 
-  if (checkCommand === 'bd') {
+  if (checkCommand === 'br') {
     const beads = await getBeadsVersion()
     if (beads) {
       const probe = await probeBeadsRuntime(beads.command)
       if (probe.ok) {
         log(`Installed ${name} via ${beads.command}: ${beads.version}`)
-        if (process.platform === 'win32' && !(await commandExists('bd'))) {
-          warn('Beads was installed, but `bd` is not visible in this shell PATH yet. The installer added the common Windows Beads directories to PATH for future shells.')
+        if (process.platform === 'win32' && !(await commandExists('br'))) {
+          warn('beads_rust was installed, but `br` is not visible in this shell PATH yet. The installer added the common beads_rust directories to PATH for future shells.')
         }
         return
       }
 
+      if (process.platform === 'linux') {
+        warn(`${name} was installed, but the detected binary failed runtime verification. Trying Linux fallback binary.`)
+        const fallbackResult = await installLinuxBrFallbackBinary()
+        if (fallbackResult.code === 0) {
+          const fallbackVersion = await getBeadsVersion()
+          if (fallbackVersion) {
+            const fallbackProbe = await probeBeadsRuntime(fallbackVersion.command)
+            if (fallbackProbe.ok) {
+              log(`Installed ${name} via fallback binary at ${fallbackVersion.command}: ${fallbackVersion.version}`)
+              return
+            }
+            warn(`${name} fallback binary still failed runtime verification.${fallbackProbe.output ? ` ${fallbackProbe.output}` : ''}`)
+          }
+        } else {
+          warn(`Linux fallback binary installation failed.${fallbackResult.stderr ? ` ${fallbackResult.stderr}` : ''}`)
+        }
+      }
+
       warn(`${name} was installed at ${beads.command}, but it still failed a runtime probe.${probe.output ? ` ${probe.output}` : ''}`)
       return
     }
 
-    warn('Beads installation completed, but the `bd` command could not be verified. Re-open PowerShell or Command Prompt and run `bd version`.')
+    if (process.platform === 'linux') {
+      warn(`${name} install completed, but no working br binary was detected. Trying Linux fallback binary.`)
+      const fallbackResult = await installLinuxBrFallbackBinary()
+      if (fallbackResult.code === 0) {
+        const fallbackVersion = await getBeadsVersion()
+        if (fallbackVersion) {
+          const fallbackProbe = await probeBeadsRuntime(fallbackVersion.command)
+          if (fallbackProbe.ok) {
+            log(`Installed ${name} via fallback binary at ${fallbackVersion.command}: ${fallbackVersion.version}`)
+            return
+          }
+          warn(`${name} fallback binary still failed runtime verification.${fallbackProbe.output ? ` ${fallbackProbe.output}` : ''}`)
+        }
+      } else {
+        warn(`Linux fallback binary installation failed.${fallbackResult.stderr ? ` ${fallbackResult.stderr}` : ''}`)
+      }
+    }
+
+    warn('beads_rust installation completed, but the `br` command could not be verified. Open a new terminal and run `br version`.')
   }
 }
 
@@ -529,16 +569,16 @@ async function checkInitShellSupport() {
 async function installAgents(paths) {
   const sourceAgents = path.join(assetsRoot(), 'agents')
   await ensureDir(paths.opencodeAgentsDir)
-  const summary = { installed: [], skipped: [] }
+  const summary = { installed: [], refreshed: [] }
 
-  for (const fileName of ['slopmachine.md', 'developer.md']) {
-    const result = await copyFileIfMissing(path.join(sourceAgents, fileName), path.join(paths.opencodeAgentsDir, fileName))
-    if (result.copied) {
+  for (const fileName of ['slopmachine.md', 'developer.md', 'slopmachine-v2.md', 'developer-v2.md']) {
+    const result = await copyFileReplacing(path.join(sourceAgents, fileName), path.join(paths.opencodeAgentsDir, fileName))
+    if (result.replaced) {
+      log(`Refreshed agent: ${fileName}`)
+      summary.refreshed.push(fileName)
+    } else {
       log(`Installed agent: ${fileName}`)
       summary.installed.push(fileName)
-    } else {
-      warn(`Skipped existing agent: ${fileName}`)
-      summary.skipped.push(fileName)
     }
   }
 
@@ -548,16 +588,16 @@ async function installAgents(paths) {
 async function installSkills(paths) {
   const sourceSkills = path.join(assetsRoot(), 'skills')
   await ensureDir(paths.globalSkillsDir)
-  const summary = { installed: [], skipped: [] }
+  const summary = { installed: [], refreshed: [] }
 
   for (const dirName of REQUIRED_SKILL_DIRS) {
-    const result = await copyDirIfMissing(path.join(sourceSkills, dirName), path.join(paths.globalSkillsDir, dirName))
-    if (result.copied) {
+    const result = await copyDirReplacing(path.join(sourceSkills, dirName), path.join(paths.globalSkillsDir, dirName))
+    if (result.replaced) {
+      log(`Refreshed skill: ${dirName}`)
+      summary.refreshed.push(dirName)
+    } else {
       log(`Installed skill: ${dirName}`)
       summary.installed.push(dirName)
-    } else {
-      warn(`Skipped existing skill: ${dirName}`)
-      summary.skipped.push(dirName)
     }
   }
 
@@ -567,17 +607,18 @@ async function installSkills(paths) {
 async function installSlopmachineAssets(paths) {
   const source = path.join(assetsRoot(), 'slopmachine')
   await ensureDir(paths.slopmachineDir)
-  const summary = { installed: [], skipped: [] }
+  const summary = { installed: [], refreshed: [] }
 
   for (const relativePath of REQUIRED_SLOPMACHINE_FILES) {
-    const result = await copyFileIfMissing(path.join(source, relativePath), path.join(paths.slopmachineDir, relativePath))
-    if (result.copied) {
-      await makeExecutableIfShellScript(path.join(paths.slopmachineDir, relativePath))
+    const targetPath = path.join(paths.slopmachineDir, relativePath)
+    const result = await copyFileReplacing(path.join(source, relativePath), targetPath)
+    await makeExecutableIfShellScript(targetPath)
+    if (result.replaced) {
+      log(`Refreshed asset: ${relativePath}`)
+      summary.refreshed.push(relativePath)
+    } else {
       log(`Installed asset: ${relativePath}`)
       summary.installed.push(relativePath)
-    } else {
-      warn(`Skipped existing asset: ${relativePath}`)
-      summary.skipped.push(relativePath)
     }
   }
 
@@ -668,31 +709,36 @@ async function collectApiKeys() {
 
 export async function runInstall() {
   const paths = buildPaths()
+  section('Setup')
   log(`Configuring theslopmachine in ${paths.home}`)
 
+  section('Dependencies')
   await ensureDependency({ name: 'git', checkCommand: 'git', installable: true })
   await ensureDependency({ name: 'python3', checkCommand: 'python3', installable: true })
   await ensureDependency({ name: 'opencode', checkCommand: 'opencode', requiredVersion: OPCODE_VERSION, installable: true })
-  await ensureDependency({ name: 'Beads (bd)', checkCommand: 'bd', requiredVersion: BEADS_VERSION, installable: true })
+  await ensureDependency({ name: 'beads_rust (br)', checkCommand: 'br', requiredVersion: null, installable: true })
   await checkDocker()
   await checkInitShellSupport()
 
+  section('Package Assets')
   const agentSummary = await installAgents(paths)
   const skillSummary = await installSkills(paths)
   const assetSummary = await installSlopmachineAssets(paths)
 
+  section('OpenCode Config')
   await maybeInstallPluginBinary()
   const keys = await collectApiKeys()
   await mergeOpencodeConfig(paths, keys)
 
+  section('Summary')
   log('Setup phase completed.')
   console.log('\ntheslopmachine setup summary')
   console.log(`- Agents installed: ${agentSummary.installed.length}`)
-  console.log(`- Agents skipped: ${agentSummary.skipped.length}`)
+  console.log(`- Agents refreshed: ${agentSummary.refreshed.length}`)
   console.log(`- Skills installed: ${skillSummary.installed.length}`)
-  console.log(`- Skills skipped: ${skillSummary.skipped.length}`)
+  console.log(`- Skills refreshed: ${skillSummary.refreshed.length}`)
   console.log(`- SlopMachine assets installed: ${assetSummary.installed.length}`)
-  console.log(`- SlopMachine assets skipped: ${assetSummary.skipped.length}`)
+  console.log(`- SlopMachine assets refreshed: ${assetSummary.refreshed.length}`)
   console.log(`- Agents directory: ${paths.opencodeAgentsDir}`)
   console.log(`- Skills directory: ${paths.globalSkillsDir}`)
   console.log(`- SlopMachine home: ${paths.slopmachineDir}`)

package/src/utils.js

@@ -13,6 +13,10 @@ export function warn(message) {
   console.warn(`[slopmachine] WARN: ${message}`)
 }
 
+export function section(title) {
+  console.log(`\n[slopmachine] ${title}`)
+}
+
 export async function pathExists(targetPath) {
   try {
     await fs.access(targetPath, fsConstants.F_OK)
@@ -35,6 +39,13 @@ export async function copyFileIfMissing(sourcePath, targetPath) {
   return { copied: true, skipped: false }
 }
 
+export async function copyFileReplacing(sourcePath, targetPath) {
+  const existed = await pathExists(targetPath)
+  await ensureDir(path.dirname(targetPath))
+  await fs.copyFile(sourcePath, targetPath)
+  return { copied: true, replaced: existed, skipped: false }
+}
+
 export async function copyDirIfMissing(sourcePath, targetPath) {
   if (await pathExists(targetPath)) {
     return { copied: false, skipped: true }
@@ -44,6 +55,14 @@ export async function copyDirIfMissing(sourcePath, targetPath) {
   return { copied: true, skipped: false }
 }
 
+export async function copyDirReplacing(sourcePath, targetPath) {
+  const existed = await pathExists(targetPath)
+  await ensureDir(path.dirname(targetPath))
+  await fs.rm(targetPath, { recursive: true, force: true })
+  await fs.cp(sourcePath, targetPath, { recursive: true })
+  return { copied: true, replaced: existed, skipped: false }
+}
+
 export async function makeExecutableIfShellScript(targetPath) {
   if (targetPath.endsWith('.sh')) {
     await fs.chmod(targetPath, 0o755)