theslopmachine 0.3.2 → 0.3.3

package/README.md

@@ -2,10 +2,10 @@
 
 Installer package for the theslopmachine workflow owner, developer agent, required skills, templates, and local support files.
 
-## Planned commands
+## Commands
 
-- `slopmachine setup`
-- `slopmachine init`
+- `slopmachine setup` - configures agents, files and scripts
+- `slopmachine init` - sets up a project
 - `slopmachine init -o` to bootstrap the project and immediately open OpenCode inside `repo/`
 
 See `MANUAL.md` for a short usage guide and workflow summary.
@@ -17,7 +17,3 @@ See `MANUAL.md` for a short usage guide and workflow summary.
 - `assets/slopmachine/`
 - `bin/`
 - `src/`
-
-## Status
-
-This package workspace is being built from the current local theslopmachine setup without modifying the live installation on this machine.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "theslopmachine",
-    "version": "0.3.2",
+    "version": "0.3.3",
     "description": "SlopMachine installer and project bootstrap CLI",
     "license": "MIT",
     "type": "module",

package/src/init.js

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import { buildPaths } from './constants.js'
-import { commandExists, ensureDir, log, pathExists, runCommand, warn } from './utils.js'
+import { ensureDir, log, pathExists, resolveCommand, runCommand, warn } from './utils.js'
 
 const GITIGNORE_ENTRIES = [
   '.DS_Store',
@@ -145,18 +145,19 @@ async function maybeOpenOpencode(targetPath, openAfterInit) {
     return
   }
 
-  if (!(await commandExists('opencode'))) {
+  const opencodeCommand = await resolveCommand('opencode')
+  if (!opencodeCommand) {
     warn('OpenCode is not available in PATH, so the project was initialized but could not be opened automatically. Launch OpenCode manually inside repo/.')
     return
   }
 
   log('Opening OpenCode in repo/')
-  const result = await runCommand('opencode', [], {
+  const result = await runCommand(opencodeCommand, [], {
     stdio: 'inherit',
     cwd: path.join(targetPath, 'repo'),
   })
   if (result.code !== 0) {
-    throw new Error('Failed to launch OpenCode')
+    warn(`Failed to launch OpenCode automatically (${result.stderr || `exit code ${result.code}`}). Launch it manually inside repo/.`)
   }
 }
 

package/src/install.js

@@ -16,12 +16,14 @@ import {
   copyDirIfMissing,
   copyFileIfMissing,
   ensureDir,
+  getGlobalNpmPackageVersion,
   log,
   makeExecutableIfShellScript,
   pathExists,
   promptText,
   promptYesNo,
   readJsonIfExists,
+  resolveCommand,
   runCommand,
   warn,
   writeJson,
@@ -72,8 +74,8 @@ async function detectPackageManagers() {
 
 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' })
+    log('Installing opencode-ai@latest globally via npm')
+    return runCommand('npm', ['install', '-g', 'opencode-ai@latest'], { stdio: 'inherit' })
   }
   if (name === 'bd') {
     log(`Installing @beads/bd@${BEADS_VERSION} globally via npm`)
@@ -134,6 +136,24 @@ async function ensureDependency({ name, checkCommand, requiredVersion, installab
     }
   }
 
+  if (name === 'opencode') {
+    const npmVersion = await getGlobalNpmPackageVersion('opencode-ai')
+    if (npmVersion) {
+      log(`opencode detected via global npm package: opencode-ai@${npmVersion}`)
+      if (requiredVersion && !npmVersion.includes(requiredVersion)) {
+        warn(`${name} version differs from tested reference ${requiredVersion}`)
+      }
+      return
+    }
+
+    const commandPath = await resolveCommand('opencode')
+    if (commandPath) {
+      log(`opencode command detected at ${commandPath}`)
+      warn(`Unable to verify ${name} version without executing the binary during setup.`)
+      return
+    }
+  }
+
   const version = await getCommandVersion(checkCommand)
   if (version) {
     log(`${name} detected: ${version}`)
@@ -158,6 +178,21 @@ async function ensureDependency({ name, checkCommand, requiredVersion, installab
   const result = await tryInstallCoreDependency(checkCommand)
   if (result.code !== 0) {
     warn(`Automatic installation for ${name} failed. Please install it manually.`)
+    return
+  }
+
+  if (name === 'opencode') {
+    const installedVersion = await getGlobalNpmPackageVersion('opencode-ai')
+    if (installedVersion) {
+      log(`Installed opencode-ai@${installedVersion}`)
+      const commandPath = await resolveCommand('opencode')
+      if (!commandPath) {
+        warn('opencode-ai was installed, but the `opencode` command is not visible in this shell PATH yet. Open a new terminal before using `slopmachine init -o`.')
+      }
+      return
+    }
+
+    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`.')
   }
 }
 

package/src/utils.js

@@ -76,6 +76,7 @@ export async function backupFile(filePath) {
 
 export async function runCommand(command, args, options = {}) {
   return new Promise((resolve, reject) => {
+    let settled = false
     const child = spawn(command, args, {
       stdio: options.stdio || 'pipe',
       cwd: options.cwd,
@@ -98,8 +99,24 @@ export async function runCommand(command, args, options = {}) {
       })
     }
 
-    child.on('error', reject)
+    child.on('error', (error) => {
+      if (settled) {
+        return
+      }
+      settled = true
+
+      if (error && error.code === 'ENOENT') {
+        resolve({ code: 127, stdout: stdoutText, stderr: error.message })
+        return
+      }
+
+      reject(error)
+    })
     child.on('close', (code) => {
+      if (settled) {
+        return
+      }
+      settled = true
       resolve({ code: code ?? 1, stdout: stdoutText, stderr: stderrText })
     })
   })
@@ -111,6 +128,62 @@ export async function commandExists(command) {
   return result.code === 0
 }
 
+export async function getGlobalNpmPackageVersion(packageName) {
+  const result = await runCommand('npm', ['list', '-g', packageName, '--depth=0', '--json'])
+  const raw = result.stdout.trim()
+
+  if (!raw) {
+    return null
+  }
+
+  try {
+    const data = JSON.parse(raw)
+    return data.dependencies?.[packageName]?.version || null
+  } catch {
+    return null
+  }
+}
+
+async function getGlobalNpmPrefix() {
+  const result = await runCommand('npm', ['prefix', '-g'])
+  if (result.code !== 0) {
+    return null
+  }
+
+  const prefix = result.stdout.trim()
+  return prefix || null
+}
+
+export async function resolveCommand(command) {
+  if (await commandExists(command)) {
+    return command
+  }
+
+  const prefix = await getGlobalNpmPrefix()
+  if (!prefix) {
+    return null
+  }
+
+  const candidates = process.platform === 'win32'
+    ? [
+        path.join(prefix, `${command}.cmd`),
+        path.join(prefix, `${command}.exe`),
+        path.join(prefix, command),
+      ]
+    : [
+        path.join(prefix, 'bin', command),
+        path.join(prefix, command),
+      ]
+
+  for (const candidate of candidates) {
+    if (await pathExists(candidate)) {
+      return candidate
+    }
+  }
+
+  return null
+}
+
 export async function findBashExecutable() {
   if (await commandExists('bash')) {
     return 'bash'