opencode-wyvern 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rhaegal222
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# opencode-wyvern
+
+Setup **modulare** per OpenCode: installi tutto, attivi quello che vuoi.
+
+Il pacchetto non contiene alcun dato privato: host, utente, chiavi SSH e
+API key vengono **richiesti/creati durante il setup**, mai salvati in locale
+(le API key finiscono solo in `~/.config/opencode/.env` sul server, `chmod 600`).
+
+## Installazione
+
+```bash
+npm install -g opencode-wyvern
+oc-setup
+```
+
+La procedura guidata:
+
+1. **Moduli** — scegli quali sezioni attivare (default: tutte).
+2. **Connessione** — solo i dati necessari ai moduli scelti
+   (host obbligatorio solo se usi SSH/sezioni remote; coi soli client basta l'alias).
+3. **Provider / plugin / claude-mem** — solo se le sezioni corrispondenti sono attive;
+   endpoint e chiavi sono richieste al volo.
+4. **Applicazione** — chiave SSH, alias, profili client e bootstrap remoto.
+
+Le sezioni restano salvate in `~/.config/opencode-wyvern/config.json`
+(solo dati non sensibili) e puoi attivarle/disattivarle in seguito.
+
+## Comandi
+
+```
+oc-setup                              avvia la procedura guidata
+oc-setup generate                     riapplica le sezioni attive dalla config
+oc-setup status                       mostra moduli, entry e provider configurati
+oc-setup activate <sezione>           attiva un modulo
+oc-setup deactivate <sezione>         disattiva un modulo
+oc-setup print <sezione>              stampa l'artefatto di una sezione
+```
+
+## Moduli
+
+| Sezione       | Dove  | Cosa fa |
+|---------------|-------|---------|
+| `ssh`         | locale | genera/riusa la chiave ed25519, alias in `~/.ssh/config`, install chiave sul server |
+| `client-pwsh` | locale | comandi `oc-*` nel profilo PowerShell (`oc-sessions`, `oc-go`, `oc-resume`, `oc-recap`, ...) |
+| `client-bash` | locale | stesso blocco in `~/.bashrc` |
+| `server`      | remoto | controlla node/npm, installa opencode se manca, crea `~/.config/opencode` + `AGENTS.md` |
+| `commands`    | remoto | comando `/baseline-ui` (`command/baseline-ui.md`) |
+| `providers`   | remoto | provider opencode in `opencode.json`; chiavi in `.env` |
+| `plugins`     | remoto | plugin npm installati nella dir config e listati in `opencode.json` |
+| `claude-mem`  | remoto | memoria: wrapper `plugins/claude-mem-plugin.js` |
+
+## Provider presets
+
+La sezione `providers` propone (checkbox): **GitHub Copilot**, **Google Gemini**,
+**OpenCode Zen**, **Anthropic Claude**, **OpenAI / Codex** e **OmniRoute**
+(gateway multi-modello con supporto `auto/*`). Le chiavi vengono chieste al setup
+solo per i provider che le richiedono (`GOOGLE_GENERATIVE_AI_API_KEY`,
+`ANTHROPIC_API_KEY`, `OPENAI_API_KEY`) e finiscono solo nel `.env` remoto.
+Per OmniRoute viene chiesto l'URL del gateway (default `http://127.0.0.1:20128`).
+
+Il modello default è scelto automaticamente (con OmniRoute: `omniroute/auto/best-coding`,
+altrimenti il primo modello del primo provider attivo), insieme a `small_model`.
+Un'opzione del setup aggiunge i tuning collaudati `tool_output` e `compaction`.
+
+## Client
+
+I client espongono i comandi `oc-*` e mostrano le **sessioni delle ultime 24 ore**
+(finestra scorrevole). In particolare `oc-sessions` elenca le sessioni recenti,
+`oc-go` apre una sessione, `oc-resume` ne riapre più di una, `oc-recap` riepiloga
+a fine connessione. Richiedono `oc-setup ssh` o una `~/.ssh/config` già pronta.
+
+## Sviluppo
+
+```bash
+node scripts/sync-client.mjs   # applica le modifiche condivise e rigenera il template pwsh (sanitizzato)
+node bin/oc-setup.js --help
+```
+
+## Sicurezza
+
+- Nessuna chiave/token/password nel pacchetto o in `config.json` locale.
+- Le API key sono scritte dal bootstrap remoto in `~/.config/opencode/.env` (`chmod 600`).
+- I file remoti viaggiano come base64 dentro lo script; con server non raggiungibile
+  lo script non viene stampato a video (evita leak delle chiavi).

package/bin/oc-setup.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import { run, cmdStatus, cmdActivate, cmdDeactivate, cmdGenerate, cmdPrint, runPrintClient } from "../src/setup.js"
+import { runUninstall } from "../src/uninstall.js"
+
+const argv = process.argv.slice(2)
+
+const HELP = `oc-setup — OpenCode Wyvern
+
+Setup modulare per OpenCode: installi tutto, attivi quello che vuoi.
+Nessun dato privato è incluso nel pacchetto: host, utente, chiavi e
+API key vengono richiesti/creati in locale durante l'esecuzione.
+
+Uso:
+  oc-setup                              avvia la procedura guidata interattiva
+  oc-setup generate                     riapplica le sezioni attive dalla config
+  oc-setup uninstall                    disinstallazione completa (client, config, cache, alias SSH)
+  oc-setup status                       mostra i moduli e lo stato
+  oc-setup activate <sezione>           attiva un modulo
+  oc-setup deactivate <sezione>         disattiva un modulo
+  oc-setup print <sezione>              stampa l'artefatto di una sezione
+  oc-setup --version | -v               mostra la versione
+  oc-setup --help | -h                  questo aiuto
+
+Sezioni:
+  ssh, client-pwsh, client-bash, server, commands, providers, plugins, claude-mem
+`
+
+if (argv.includes("--help") || argv.includes("-h")) {
+  console.log(HELP)
+  process.exit(0)
+}
+if (argv.includes("--version") || argv.includes("-v")) {
+  const meta = await import("../package.json", { with: { type: "json" } })
+  console.log(meta.default.version)
+  process.exit(0)
+}
+
+const printIdx = argv.indexOf("--print-client")
+if (printIdx !== -1) {
+  const kind = argv[printIdx + 1]
+  if (kind !== "pwsh" && kind !== "bash") {
+    console.error("uso: oc-setup --print-client <pwsh|bash>")
+    process.exit(2)
+  }
+  await runPrintClient(kind)
+  process.exit(0)
+}
+
+const [sub, arg1] = argv
+try {
+  switch (sub) {
+    case "status":
+      await cmdStatus()
+      break
+    case "activate":
+      if (!arg1) fail("uso: oc-setup activate <sezione>")
+      await cmdActivate(arg1)
+      break
+    case "deactivate":
+      if (!arg1) fail("uso: oc-setup deactivate <sezione>")
+      await cmdDeactivate(arg1)
+      break
+    case "generate":
+      await cmdGenerate()
+      break
+    case "uninstall":
+      await runUninstall()
+      break
+    case "print":
+      if (!arg1) fail("uso: oc-setup print <sezione>")
+      await cmdPrint(arg1)
+      break
+    case undefined:
+      await run(argv)
+      break
+    default:
+      fail(`comando sconosciuto: ${sub}`)
+  }
+} catch (err) {
+  console.error(`\n[error] ${err && err.message ? err.message : err}`)
+  process.exit(1)
+}
+
+function fail(msg) {
+  console.error(`[error] ${msg}`)
+  process.exit(2)
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "opencode-wyvern",
+  "version": "0.1.0",
+  "description": "Setup modulare per OpenCode: SSH, client PowerShell/bash (comandi oc-*), configurazione server opencode, provider, plugin e comandi custom. Installi tutto, attivi quello che vuoi.",
+  "type": "module",
+  "license": "MIT",
+  "author": {
+    "name": "Rhaegal222",
+    "url": "https://github.com/Rhaegal222"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "oc-setup": "bin/oc-setup.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "opencode",
+    "ssh",
+    "setup",
+    "modular",
+    "cli",
+    "claude-mem",
+    "powershell",
+    "bash"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rhaegal222/opencode-wyvern.git"
+  },
+  "scripts": {
+    "test": "node bin/oc-setup.js --help"
+  }
+}

package/src/client.js

@@ -0,0 +1,109 @@
+import fs from "node:fs"
+import crypto from "node:crypto"
+import { render, readTemplate } from "./config.js"
+import { pwshProfilePath, bashRcPath } from "./shell.js"
+import { c } from "./prompts.js"
+
+export const MARKER = "# ---- OpenCode Wyvern (auto-generato) ----"
+/** Marker storici: un blocco generato in passato va comunque rimosso. */
+export const LEGACY_MARKERS = ["# ---- Opencode Remote (auto-generato) ----"]
+
+/** Mappa tipo template -> file di profilo su cui appende il blocco. */
+const TARGETS = {
+  pwsh: { tpl: "client-pwsh.ps1", path: pwshProfilePath },
+  bash: { tpl: "client-bash.sh", path: bashRcPath },
+}
+
+/**
+ * Blocco client renderizzato con i valori reali.
+ * Nessun dato sensibile: solo alias/host/user/dir, mai chiavi o password.
+ */
+export function renderClient(kind, { server, host, user, dir }) {
+  const vars = {
+    OC_SERVER: server || "remote-server",
+    OC_HOST: host || "localhost",
+    OC_USER: user || "user",
+    OC_DIR: dir || "~",
+  }
+  const tpl = readTemplate(TARGETS[kind].tpl)
+  return render(tpl, vars).replace(/\r\n/g, "\n")
+}
+
+/** Sostituisce/crea il blocco generato in un profilo, con backup. */
+function upsertBlock(filePath, block, { dryRun = false } = {}) {
+  const existed = fs.existsSync(filePath)
+  let content = existed ? fs.readFileSync(filePath, "utf8") : ""
+
+  if (content.trim() !== "" && !content.endsWith("\n")) content += "\n"
+
+  // rimuove ogni blocco già generato (marker attuale o legacy), sempre in coda
+  const all = [MARKER, ...LEGACY_MARKERS]
+  const hits = all.map((m) => content.indexOf(m)).filter((i) => i !== -1)
+  if (hits.length) {
+    const start = Math.min(...hits)
+    content = content.slice(0, start)
+    if (content !== "" && !content.endsWith("\n")) content += "\n"
+  }
+
+  const stamp = `# --- installato da oc-setup il ${new Date().toISOString().slice(0, 10)} ---`
+  const blockOut = block.replace(
+    `${MARKER}\n`,
+    `${MARKER}\n${stamp}\n`
+  )
+
+  let backup = null
+  if (existed && !dryRun) {
+    backup = `${filePath}.bak-${crypto.randomBytes(3).toString("hex")}`
+    fs.writeFileSync(backup, content, "utf8")
+  }
+  if (!dryRun) {
+    fs.writeFileSync(filePath, content + blockOut + "\n", "utf8")
+  }
+  return { filePath, backup, changed: true, dryRun }
+}
+
+/**
+ * Rimuove i blocchi client auto-generati (marker attuale o legacy) da un
+ * profilo, con backup dell'originale. Utile per la disinstallazione.
+ */
+export function stripClientBlock(filePath) {
+  if (!fs.existsSync(filePath)) return { filePath, changed: false }
+  const content = fs.readFileSync(filePath, "utf8")
+  const all = [MARKER, ...LEGACY_MARKERS]
+  const hits = all.map((m) => content.indexOf(m)).filter((i) => i !== -1)
+  if (!hits.length) return { filePath, changed: false }
+  const start = Math.min(...hits)
+  const stripped = content.slice(0, start).replace(/\s+$/, "")
+  const backup = `${filePath}.bak-${crypto.randomBytes(3).toString("hex")}`
+  fs.writeFileSync(backup, content, "utf8")
+  fs.writeFileSync(filePath, stripped ? stripped + "\n" : "", "utf8")
+  return { filePath, backup, changed: true }
+}
+
+/**
+ * Installa i comandi client `oc-*` nei profili richiesti.
+ * `onlyPrint` (null | "pwsh" | "bash") stampa il blocco renderizzato
+ * senza modificare file. `targets` è l'array dei tipi da installare.
+ */
+export async function installClient(cfg, { targets = ["pwsh", "bash"], onlyPrint = null } = {}) {
+  if (onlyPrint) {
+    const kind = onlyPrint === "bash" ? "bash" : "pwsh"
+    console.log(renderClient(kind, cfg))
+    return { printed: true, kind }
+  }
+
+  const results = []
+  for (const t of targets) {
+    const target = TARGETS[t]
+    if (!target) continue
+    const block = renderClient(t, cfg)
+    results.push(upsertBlock(target.path(), block))
+  }
+
+  console.log(c.green("\nClient installato:"))
+  for (const r of results) {
+    console.log(`  - ${r.filePath}${r.backup ? `  (backup: ${r.backup})` : ""}`)
+  }
+  console.log(c.dim("\nRicarica il profilo con:  . $PROFILE   (PowerShell)  /  source ~/.bashrc   (bash)"))
+  return { installed: results }
+}

package/src/config.js

@@ -0,0 +1,64 @@
+import fs from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { configDir, configFilePath } from "./shell.js"
+
+/**
+ * Configurazione persistente della CLI.
+ *
+ * NB: NON contiene mai chiavi API né password. I segreti API vengono scritti
+ * esclusivamente nel file `.env` sul SERVER (chmod 600), mai qui.
+ */
+export function loadConfig() {
+  try {
+    const f = configFilePath()
+    if (!fs.existsSync(f)) return {}
+    return JSON.parse(fs.readFileSync(f, "utf8"))
+  } catch {
+    return {}
+  }
+}
+
+export function saveConfig(cfg) {
+  fs.mkdirSync(configDir(), { recursive: true })
+  fs.writeFileSync(configFilePath(), JSON.stringify(cfg, null, 2) + "\n", "utf8")
+  try {
+    fs.chmodSync(configFilePath(), 0o600)
+  } catch {
+    /* non critico */
+  }
+}
+
+export function maskSecret(value) {
+  if (!value) return value
+  if (value.length <= 8) return "*".repeat(value.length)
+  return value.slice(0, 4) + "*".repeat(Math.max(4, value.length - 8)) + value.slice(-4)
+}
+
+export function ensureDir(p) {
+  fs.mkdirSync(p, { recursive: true })
+  return p
+}
+
+export function templatePath(name) {
+  return path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "templates", name)
+}
+
+export function readTemplate(name) {
+  const p = templatePath(name)
+  if (!fs.existsSync(p)) {
+    throw new Error(`template mancante: ${name}`)
+  }
+  return fs.readFileSync(p, "utf8")
+}
+
+/**
+ * Sostituisce i segnaposto `__KEY__` con i valori forniti.
+ */
+export function render(template, vars) {
+  let out = template
+  for (const [key, value] of Object.entries(vars)) {
+    out = out.split(`__${key.toUpperCase()}__`).join(String(value))
+  }
+  return out
+}

package/src/prompts.js

@@ -0,0 +1,164 @@
+import { stdin as input, stdout as output } from "node:process"
+
+const color = (code, s) => `\x1b[${code}m${s}\x1b[0m`
+export const c = {
+  dim: (s) => color(90, s),
+  cyan: (s) => color(36, s),
+  green: (s) => color(32, s),
+  yellow: (s) => color(33, s),
+  red: (s) => color(31, s),
+  bold: (s) => color(1, s),
+}
+
+function enableRaw() {
+  try {
+    input.setRawMode(true)
+    input.resume()
+    input.setEncoding("utf8")
+    return true
+  } catch {
+    return false // stdin non interattivo
+  }
+}
+
+/**
+ * Fallback senza TTY: legge lo stdin a righe e le mette in coda, così
+ * più domande successive consumano le risposte in ordine (utile per
+ * piping/test e ambiente completamente non interattivo).
+ */
+const fallbackQueue = []
+
+function readLineFallback(done) {
+  const next = () => {
+    if (fallbackQueue.length) {
+      const v = fallbackQueue.shift()
+      return done(v)
+    }
+    const onData = (chunk) => {
+      const text = chunk.toString()
+      const parts = text.split(/\r\n|\r|\n/)
+      fallbackQueue.push(...parts)
+      input.removeListener("data", onData)
+      next()
+    }
+    input.on("data", onData)
+    input.resume()
+  }
+  next()
+}
+
+/** Legge una riga da tastiera. `masked` oscura la digitazione (per segreti); */
+/** gestisce backspace e Ctrl+C. */
+export function readLine({ masked = false, allowEmpty = false } = {}, done) {
+  if (!enableRaw()) {
+    readLineFallback(done)
+    return
+  }
+
+  let buf = ""
+  const onData = (chunk) => {
+    for (const ch of chunk) {
+      if (ch === "\r" || ch === "\n") {
+        if (!allowEmpty && buf === "") continue
+        input.removeListener("data", onData)
+        input.setRawMode(false)
+        input.pause()
+        output.write("\n")
+        return done(buf)
+      }
+      if (ch === "\u0003") {
+        input.setRawMode(false)
+        input.pause()
+        process.exit(130)
+      }
+      if (ch === "\u007f" || ch === "\b") {
+        if (buf.length) {
+          buf = buf.slice(0, -1)
+          output.write("\b \b")
+        }
+      } else {
+        buf += ch
+        output.write(masked ? "*" : ch)
+      }
+    }
+  }
+  input.on("data", onData)
+}
+
+/** Domanda a testo semplice con default opzionale. */
+export async function ask(question, { defaultValue = "", hint = "", validate } = {}) {
+  const suffix = hint ? ` ${c.dim(`(${hint})`)}` : ""
+  const def = defaultValue ? c.dim(`[${defaultValue}]`) : ""
+  // eslint-disable-next-line no-constant-condition
+  for (;;) {
+    output.write(`${c.cyan("?")} ${question}${suffix} ${def}\n> `)
+    const raw = await new Promise((resolve) => readLine({}, resolve))
+    const value = raw.trim() === "" ? defaultValue : raw.trim()
+    if (validate && !validate(value)) {
+      console.log(c.yellow("  risposta non valida, riprova."))
+      continue
+    }
+    return value
+  }
+}
+
+/** Domanda sì/no con default indicato in maiuscolo. */
+export async function confirm(question, defaultValue = false) {
+  const hint = defaultValue ? "S/n" : "s/N"
+  // eslint-disable-next-line no-constant-condition
+  for (;;) {
+    output.write(`${c.cyan("?")} ${question} ${c.dim(`(${hint})`)}\n> `)
+    const a = (await new Promise((resolve) => readLine({}, resolve))).trim().toLowerCase()
+    if (a === "") return defaultValue
+    if (/^(s|si|sì|y|yes)$/.test(a)) return true
+    if (/^(n|no)$/.test(a)) return false
+    console.log(c.yellow("  rispondi s o n."))
+  }
+}
+
+/** Selezione singola (indice numerico). */
+export async function select(question, choices, { defaultValue = 0 } = {}) {
+  console.log(`\n${c.cyan("?")} ${question}`)
+  choices.forEach((choice, i) => {
+    console.log(`  ${i + 1}. ${choice.label}`)
+  })
+  return choices[Number(await ask("Scelta (numero)", {
+    defaultValue: String(defaultValue + 1),
+    validate: (v) => /^\d+$/.test(v) && Number(v) >= 1 && Number(v) <= choices.length,
+  })) - 1]
+}
+
+/** Selezione multipla: numeri separati da virgola/spazio (es. "1,3,5"); invio = nessuna. */
+export async function checkbox(question, choices, { defaultIndices = [] } = {}) {
+  console.log(`\n${c.cyan("?")} ${question} ${c.dim("(invio = nessuno; es. 1,3,5)")}`)
+  choices.forEach((choice, i) => {
+    const sel = defaultIndices.includes(i) ? "•" : " "
+    console.log(`  ${sel} ${i + 1}. ${choice.label}`)
+  })
+  const answer = await ask("Seleziona (es. 1,3,5)", {
+    validate: (v) => {
+      const nums = v.split(/[\s,]+/).filter(Boolean)
+      if (!nums.length) return true // invio = nessuno (salta)
+      return nums.every((n) => /^\d+$/.test(n) && Number(n) >= 1 && Number(n) <= choices.length)
+    },
+  })
+  const nums = answer.split(/[\s,]+/).filter(Boolean)
+  if (!nums.length) return []
+  return [...new Set(nums.map((n) => Number(n) - 1))].map((i) => choices[i])
+}
+
+/** Input mascherato per segreti (API key ecc.). */
+export async function secret(question, { allowEmpty = false } = {}) {
+  output.write(`${c.cyan("?")} ${question}\n> `)
+  return new Promise((resolve) => readLine({ masked: true, allowEmpty }, (v) => resolve(v)))
+}
+
+export function closePrompts() {
+  input.removeAllListeners("data")
+  try {
+    input.setRawMode(false)
+  } catch {
+    /* ok */
+  }
+  input.pause()
+}