theslopmachine 0.3.0

package/src/install.js

@@ -0,0 +1,330 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+import {
+  BEADS_VERSION,
+  buildPaths,
+  MCP_ENTRIES,
+  OPCODE_VERSION,
+  PACKAGE_ROOT,
+  REQUIRED_SKILL_DIRS,
+  REQUIRED_SLOPMACHINE_FILES,
+} from './constants.js'
+import {
+  backupFile,
+  commandExists,
+  copyDirIfMissing,
+  copyFileIfMissing,
+  ensureDir,
+  log,
+  makeExecutableIfShellScript,
+  pathExists,
+  promptText,
+  promptYesNo,
+  readJsonIfExists,
+  runCommand,
+  warn,
+  writeJson,
+} from './utils.js'
+
+function assetsRoot() {
+  return path.join(PACKAGE_ROOT, 'assets')
+}
+
+async function getCommandVersion(command, args = ['--version']) {
+  const exists = await commandExists(command)
+  if (!exists) return null
+  const result = await runCommand(command, args)
+  if (result.code !== 0) return null
+  return (result.stdout || result.stderr).trim()
+}
+
+async function detectPackageManagers() {
+  return {
+    brew: await commandExists('brew'),
+    apt: await commandExists('apt-get'),
+    dnf: await commandExists('dnf'),
+    winget: await commandExists('winget'),
+    choco: await commandExists('choco'),
+  }
+}
+
+async function tryInstallCoreDependency(name) {
+  if (name === 'opencode') {
+    log(`Installing opencode-ai@${OPCODE_VERSION} globally via npm`)
+    return runCommand('npm', ['install', '-g', `opencode-ai@${OPCODE_VERSION}`], { stdio: 'inherit' })
+  }
+  if (name === 'bd') {
+    log(`Installing @beads/bd@${BEADS_VERSION} globally via npm`)
+    return runCommand('npm', ['install', '-g', `@beads/bd@${BEADS_VERSION}`], { stdio: 'inherit' })
+  }
+
+  const managers = await detectPackageManagers()
+  const installMap = {
+    git: {
+      brew: ['brew', ['install', 'git']],
+      apt: ['sudo', ['apt-get', 'install', '-y', 'git']],
+      dnf: ['sudo', ['dnf', 'install', '-y', 'git']],
+      winget: ['winget', ['install', '--id', 'Git.Git', '-e']],
+      choco: ['choco', ['install', 'git', '-y']],
+    },
+    python3: {
+      brew: ['brew', ['install', 'python@3.11']],
+      apt: ['sudo', ['apt-get', 'install', '-y', 'python3']],
+      dnf: ['sudo', ['dnf', 'install', '-y', 'python3']],
+      winget: ['winget', ['install', '--id', 'Python.Python.3.11', '-e']],
+      choco: ['choco', ['install', 'python', '--version=3.11.7', '-y']],
+    },
+  }
+
+  const platformKey = managers.brew
+    ? 'brew'
+    : managers.apt
+      ? 'apt'
+      : managers.dnf
+        ? 'dnf'
+        : managers.winget
+          ? 'winget'
+          : managers.choco
+            ? 'choco'
+            : null
+  const entry = installMap[name]?.[platformKey]
+  if (!entry) {
+    return { code: 1, stdout: '', stderr: `No automated install path for ${name} on this platform` }
+  }
+
+  if (platformKey === 'apt') {
+    const updateResult = await runCommand('sudo', ['apt-get', 'update'], { stdio: 'inherit' })
+    if (updateResult.code !== 0) return updateResult
+  }
+
+  return runCommand(entry[0], entry[1], { stdio: 'inherit' })
+}
+
+async function ensureDependency({ name, checkCommand, requiredVersion, installable }) {
+  const version = await getCommandVersion(checkCommand)
+  if (version) {
+    log(`${name} detected: ${version}`)
+    if (requiredVersion && !version.includes(requiredVersion)) {
+      warn(`${name} version differs from tested reference ${requiredVersion}`)
+    }
+    return
+  }
+
+  warn(`${name} is not installed or not available in PATH`)
+
+  if (!installable) {
+    return
+  }
+
+  const shouldInstall = await promptYesNo(`Attempt to install ${name} automatically?`, true)
+  if (!shouldInstall) {
+    warn(`Skipping ${name} installation. Please install it manually before using SlopMachine.`)
+    return
+  }
+
+  const result = await tryInstallCoreDependency(checkCommand)
+  if (result.code !== 0) {
+    warn(`Automatic installation for ${name} failed. Please install it manually.`)
+  }
+}
+
+async function checkDocker() {
+  const dockerVersion = await getCommandVersion('docker')
+  const composeVersion = await getCommandVersion('docker', ['compose', 'version'])
+  if (!dockerVersion || !composeVersion) {
+    warn('Docker and Docker Compose are required for SlopMachine workflows. Please install Docker Desktop or the Docker Engine + Compose plugin and start Docker.')
+    return
+  }
+  log(`docker detected: ${dockerVersion}`)
+  log(`docker compose detected: ${composeVersion}`)
+
+  const info = await runCommand('docker', ['info'])
+  if (info.code !== 0) {
+    warn('Docker is installed but does not appear to be running. Start Docker before using SlopMachine.')
+  }
+}
+
+async function checkInitShellSupport() {
+  const hasNode = await commandExists('node')
+  if (!hasNode) {
+    warn('`slopmachine init` requires Node.js to remain available on this machine after installation.')
+  }
+}
+
+async function installAgents(paths) {
+  const sourceAgents = path.join(assetsRoot(), 'agents')
+  await ensureDir(paths.opencodeAgentsDir)
+  const summary = { installed: [], skipped: [] }
+
+  for (const fileName of ['slopmachine.md', 'developer.md']) {
+    const result = await copyFileIfMissing(path.join(sourceAgents, fileName), path.join(paths.opencodeAgentsDir, fileName))
+    if (result.copied) {
+      log(`Installed agent: ${fileName}`)
+      summary.installed.push(fileName)
+    } else {
+      warn(`Skipped existing agent: ${fileName}`)
+      summary.skipped.push(fileName)
+    }
+  }
+
+  return summary
+}
+
+async function installSkills(paths) {
+  const sourceSkills = path.join(assetsRoot(), 'skills')
+  await ensureDir(paths.globalSkillsDir)
+  const summary = { installed: [], skipped: [] }
+
+  for (const dirName of REQUIRED_SKILL_DIRS) {
+    const result = await copyDirIfMissing(path.join(sourceSkills, dirName), path.join(paths.globalSkillsDir, dirName))
+    if (result.copied) {
+      log(`Installed skill: ${dirName}`)
+      summary.installed.push(dirName)
+    } else {
+      warn(`Skipped existing skill: ${dirName}`)
+      summary.skipped.push(dirName)
+    }
+  }
+
+  return summary
+}
+
+async function installSlopmachineAssets(paths) {
+  const source = path.join(assetsRoot(), 'slopmachine')
+  await ensureDir(paths.slopmachineDir)
+  const summary = { installed: [], skipped: [] }
+
+  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))
+      log(`Installed asset: ${relativePath}`)
+      summary.installed.push(relativePath)
+    } else {
+      warn(`Skipped existing asset: ${relativePath}`)
+      summary.skipped.push(relativePath)
+    }
+  }
+
+  return summary
+}
+
+async function mergeOpencodeConfig(paths, options) {
+  await ensureDir(paths.opencodeDir)
+  const backupPath = await backupFile(paths.opencodeConfigPath)
+  if (backupPath) {
+    log(`Backed up existing opencode.json to ${backupPath}`)
+  }
+
+  const existing = (await readJsonIfExists(paths.opencodeConfigPath)) || {
+    $schema: 'https://opencode.ai/config.json',
+  }
+
+  const plugins = Array.isArray(existing.plugin) ? [...existing.plugin] : []
+  if (!plugins.includes('oc-chatgpt-multi-auth')) {
+    plugins.push('oc-chatgpt-multi-auth')
+  }
+  existing.plugin = plugins
+
+  const mcp = typeof existing.mcp === 'object' && existing.mcp !== null ? { ...existing.mcp } : {}
+  mcp['chrome-devtools'] = MCP_ENTRIES['chrome-devtools']
+  mcp.context7 = {
+    ...MCP_ENTRIES.context7,
+    headers: {
+      CONTEXT7_API_KEY: options.context7ApiKey,
+    },
+  }
+  mcp.exa = {
+    ...MCP_ENTRIES.exa,
+    headers: {
+      EXA_API_KEY: options.exaApiKey,
+    },
+  }
+  mcp.shadcn = MCP_ENTRIES.shadcn
+  existing.mcp = mcp
+
+  await writeJson(paths.opencodeConfigPath, existing)
+  log(`Updated ${paths.opencodeConfigPath}`)
+}
+
+async function maybeInstallPluginBinary() {
+  if (process.env.SLOPMACHINE_PLUGIN_BOOTSTRAP === '0') {
+    return
+  }
+
+  if (process.env.SLOPMACHINE_PLUGIN_BOOTSTRAP === '1') {
+    const forced = await runCommand('npx', ['-y', 'oc-chatgpt-multi-auth@latest'], { stdio: 'inherit' })
+    if (forced.code !== 0) {
+      warn('Plugin bootstrap command did not complete successfully. The opencode.json plugin entry was still configured.')
+    }
+    return
+  }
+
+  const shouldInstall = await promptYesNo('Run `npx -y oc-chatgpt-multi-auth@latest` now?', false)
+  if (!shouldInstall) {
+    return
+  }
+  const result = await runCommand('npx', ['-y', 'oc-chatgpt-multi-auth@latest'], { stdio: 'inherit' })
+  if (result.code !== 0) {
+    warn('Plugin bootstrap command did not complete successfully. The opencode.json plugin entry was still configured.')
+  }
+}
+
+async function collectApiKeys() {
+  const forcedContext7 = process.env.SLOPMACHINE_CONTEXT7_API_KEY
+  const forcedExa = process.env.SLOPMACHINE_EXA_API_KEY
+  const nonInteractive = process.env.SLOPMACHINE_NONINTERACTIVE === '1'
+
+  if (forcedContext7 !== undefined || forcedExa !== undefined || nonInteractive) {
+    return {
+      context7ApiKey: forcedContext7 || '',
+      exaApiKey: forcedExa || '',
+    }
+  }
+
+  console.log('Context7 API key: https://context7.com')
+  const context7ApiKey = await promptText('Paste Context7 API key or leave blank to skip', '')
+
+  console.log('Exa API key: https://exa.ai')
+  const exaApiKey = await promptText('Paste Exa API key or leave blank to skip', '')
+
+  return { context7ApiKey, exaApiKey }
+}
+
+export async function runInstall() {
+  const paths = buildPaths()
+  log(`Installing SlopMachine into ${paths.home}`)
+
+  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 checkDocker()
+  await checkInitShellSupport()
+
+  const agentSummary = await installAgents(paths)
+  const skillSummary = await installSkills(paths)
+  const assetSummary = await installSlopmachineAssets(paths)
+
+  await maybeInstallPluginBinary()
+  const keys = await collectApiKeys()
+  await mergeOpencodeConfig(paths, keys)
+
+  log('Installation phase completed.')
+  console.log('\nSlopMachine install summary')
+  console.log(`- Agents installed: ${agentSummary.installed.length}`)
+  console.log(`- Agents skipped: ${agentSummary.skipped.length}`)
+  console.log(`- Skills installed: ${skillSummary.installed.length}`)
+  console.log(`- Skills skipped: ${skillSummary.skipped.length}`)
+  console.log(`- SlopMachine assets installed: ${assetSummary.installed.length}`)
+  console.log(`- SlopMachine assets skipped: ${assetSummary.skipped.length}`)
+  console.log(`- Agents directory: ${paths.opencodeAgentsDir}`)
+  console.log(`- Skills directory: ${paths.globalSkillsDir}`)
+  console.log(`- SlopMachine home: ${paths.slopmachineDir}`)
+  console.log(`- OpenCode config: ${paths.opencodeConfigPath}`)
+  console.log('\nNext steps')
+  console.log('- Review any warnings above for skipped files or missing external dependencies.')
+  console.log('- If Docker was reported as stopped, start Docker before using SlopMachine on a real project.')
+  console.log('- Run `slopmachine init` inside a project directory to bootstrap a new SlopMachine workspace.')
+}

package/src/utils.js

@@ -0,0 +1,162 @@
+import fs from 'node:fs/promises'
+import { constants as fsConstants } from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import readline from 'node:readline/promises'
+import { stdin as input, stdout as output } from 'node:process'
+
+export function log(message) {
+  console.log(`[slopmachine] ${message}`)
+}
+
+export function warn(message) {
+  console.warn(`[slopmachine] WARN: ${message}`)
+}
+
+export async function pathExists(targetPath) {
+  try {
+    await fs.access(targetPath, fsConstants.F_OK)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function ensureDir(targetPath) {
+  await fs.mkdir(targetPath, { recursive: true })
+}
+
+export async function copyFileIfMissing(sourcePath, targetPath) {
+  if (await pathExists(targetPath)) {
+    return { copied: false, skipped: true }
+  }
+  await ensureDir(path.dirname(targetPath))
+  await fs.copyFile(sourcePath, targetPath)
+  return { copied: true, skipped: false }
+}
+
+export async function copyDirIfMissing(sourcePath, targetPath) {
+  if (await pathExists(targetPath)) {
+    return { copied: false, skipped: true }
+  }
+  await ensureDir(path.dirname(targetPath))
+  await fs.cp(sourcePath, targetPath, { recursive: true })
+  return { copied: true, skipped: false }
+}
+
+export async function makeExecutableIfShellScript(targetPath) {
+  if (targetPath.endsWith('.sh')) {
+    await fs.chmod(targetPath, 0o755)
+  }
+}
+
+export async function readJsonIfExists(filePath) {
+  if (!(await pathExists(filePath))) {
+    return null
+  }
+  const content = await fs.readFile(filePath, 'utf8')
+  return JSON.parse(content)
+}
+
+export async function writeJson(filePath, value) {
+  await ensureDir(path.dirname(filePath))
+  await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}
+`, 'utf8')
+}
+
+export async function backupFile(filePath) {
+  if (!(await pathExists(filePath))) {
+    return null
+  }
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-')
+  const backupPath = `${filePath}.backup-${stamp}`
+  await fs.copyFile(filePath, backupPath)
+  return backupPath
+}
+
+export async function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: options.stdio || 'pipe',
+      cwd: options.cwd,
+      shell: options.shell || false,
+      env: options.env || process.env,
+    })
+
+    let stdoutText = ''
+    let stderrText = ''
+
+    if (child.stdout) {
+      child.stdout.on('data', (chunk) => {
+        stdoutText += chunk.toString()
+      })
+    }
+
+    if (child.stderr) {
+      child.stderr.on('data', (chunk) => {
+        stderrText += chunk.toString()
+      })
+    }
+
+    child.on('error', reject)
+    child.on('close', (code) => {
+      resolve({ code: code ?? 1, stdout: stdoutText, stderr: stderrText })
+    })
+  })
+}
+
+export async function commandExists(command) {
+  const checker = process.platform === 'win32' ? 'where' : 'which'
+  const result = await runCommand(checker, [command])
+  return result.code === 0
+}
+
+export async function findBashExecutable() {
+  if (await commandExists('bash')) {
+    return 'bash'
+  }
+
+  if (process.platform !== 'win32') {
+    return null
+  }
+
+  const candidates = [
+    path.join(process.env.ProgramFiles || '', 'Git', 'bin', 'bash.exe'),
+    path.join(process.env['ProgramFiles(x86)'] || '', 'Git', 'bin', 'bash.exe'),
+    path.join(process.env.ProgramFiles || '', 'Git', 'usr', 'bin', 'bash.exe'),
+    path.join(process.env['ProgramFiles(x86)'] || '', 'Git', 'usr', 'bin', 'bash.exe'),
+  ].filter(Boolean)
+
+  for (const candidate of candidates) {
+    if (candidate && await pathExists(candidate)) {
+      return candidate
+    }
+  }
+
+  return null
+}
+
+export async function promptText(question, defaultValue = '') {
+  const rl = readline.createInterface({ input, output })
+  try {
+    const suffix = defaultValue ? ` [${defaultValue}]` : ''
+    const answer = await rl.question(`${question}${suffix}: `)
+    return answer.trim() || defaultValue
+  } finally {
+    rl.close()
+  }
+}
+
+export async function promptYesNo(question, defaultYes = true) {
+  const rl = readline.createInterface({ input, output })
+  try {
+    const suffix = defaultYes ? ' [Y/n]' : ' [y/N]'
+    const answer = (await rl.question(`${question}${suffix}: `)).trim().toLowerCase()
+    if (!answer) {
+      return defaultYes
+    }
+    return answer === 'y' || answer === 'yes'
+  } finally {
+    rl.close()
+  }
+}