vibeoscore 1.0.2 → 1.0.9

package/routes/pricing.js

@@ -1,62 +0,0 @@
-import { parseOpenRouterTurnCost, modelCostPerTurn, normalizeModelId, MODEL_USD_PER_TURN } from "../lib/delegation.js"
-
-const pricingCache = new Map()
-let lastFetch = 0
-const CACHE_TTL = 10 * 60 * 1000
-
-export async function pricingRoutes(fastify) {
-  fastify.post("/api/v1/pricing/fetch", async (request, reply) => {
-    const { openrouter_key, force } = request.body || {}
-
-    const now = Date.now()
-    if (!force && pricingCache.size > 0 && (now - lastFetch) < CACHE_TTL) {
-      return { cached: true, models: Object.fromEntries(pricingCache), count: pricingCache.size }
-    }
-
-    if (!openrouter_key) {
-      return reply.code(400).send({ error: "openrouter_key is required for live fetch" })
-    }
-
-    try {
-      const res = await fetch("https://openrouter.ai/api/v1/models", {
-        headers: { Authorization: "Bearer " + openrouter_key },
-        signal: AbortSignal.timeout(10000),
-      })
-
-      if (!res.ok) {
-        return reply.code(res.status).send({ error: "openrouter api error", status: res.status })
-      }
-
-      const body = await res.json()
-      const list = body?.data || []
-      const pricingMap = {}
-
-      for (const m of list) {
-        const dynTurnCost = parseOpenRouterTurnCost(m)
-        if (dynTurnCost != null && Number.isFinite(dynTurnCost)) {
-          const rawId = m.id || ""
-          pricingMap[normalizeModelId(rawId)] = dynTurnCost
-          pricingCache.set(normalizeModelId(rawId), dynTurnCost)
-        }
-      }
-
-      lastFetch = now
-      return { cached: false, models: pricingMap, count: Object.keys(pricingMap).length }
-    } catch (err) {
-      return reply.code(502).send({ error: "failed to fetch pricing", message: err.message })
-    }
-  })
-
-  fastify.post("/api/v1/pricing/lookup", async (request, reply) => {
-    const { model } = request.body || {}
-    if (!model) {
-      return reply.code(400).send({ error: "model is required" })
-    }
-    const cost = modelCostPerTurn(model, Object.fromEntries(pricingCache))
-    return { model: normalizeModelId(model), cost_per_turn: cost ?? null, in_cache: pricingCache.has(normalizeModelId(model)) }
-  })
-
-  fastify.get("/api/v1/pricing/static", async (request, reply) => {
-    return { models: MODEL_USD_PER_TURN, count: Object.keys(MODEL_USD_PER_TURN).length }
-  })
-}

package/routes/stress.js

@@ -1,30 +0,0 @@
-import { scoreStress, getStressLevel, buildStressFooter } from "../lib/stress.js"
-
-export async function stressRoutes(fastify) {
-  fastify.post("/api/v1/stress/score", async (request, reply) => {
-    const { text } = request.body || {}
-    if (!text) {
-      return reply.code(400).send({ error: "text is required" })
-    }
-    const score = scoreStress(text)
-    const level = getStressLevel(score)
-    const footer = buildStressFooter(score)
-    return { score, level: level.level, gauge: level.gauge, directive: level.directive, footer }
-  })
-
-  fastify.post("/api/v1/stress/level", async (request, reply) => {
-    const { score } = request.body || {}
-    if (score === undefined || score === null) {
-      return reply.code(400).send({ error: "score is required" })
-    }
-    const numScore = Number(score)
-    if (!Number.isFinite(numScore)) {
-      return reply.code(400).send({ error: "score must be a finite number" })
-    }
-    if (numScore < 0) {
-      return reply.code(400).send({ error: "score must be non-negative" })
-    }
-    const level = getStressLevel(numScore)
-    return level
-  })
-}

package/routes/tdd.js

@@ -1,68 +0,0 @@
-import { extractExports, inferFunctionParams, inferTypeFromName, buildTestSkeleton } from "../lib/tdd.js"
-
-export async function tddRoutes(fastify) {
-  fastify.post("/api/v1/tdd/exports", async (request, reply) => {
-    try {
-      const { source_content, ext } = request.body || {}
-      if (!source_content || typeof source_content !== "string") {
-        return reply.code(400).send({ error: "source_content is required and must be a string", code: "INVALID_INPUT" })
-      }
-      if (!ext || typeof ext !== "string") {
-        return reply.code(400).send({ error: "ext is required and must be a string", code: "INVALID_INPUT" })
-      }
-      const exports = extractExports(source_content, ext)
-      return { exports }
-    } catch (err) {
-      request.log.error(err, "tdd/exports error")
-      return reply.code(500).send({ error: "Internal server error", code: "INTERNAL_ERROR" })
-    }
-  })
-
-  fastify.post("/api/v1/tdd/params", async (request, reply) => {
-    try {
-      const { source_content, func_name } = request.body || {}
-      if (!source_content || typeof source_content !== "string") {
-        return reply.code(400).send({ error: "source_content is required and must be a string", code: "INVALID_INPUT" })
-      }
-      if (!func_name || typeof func_name !== "string") {
-        return reply.code(400).send({ error: "func_name is required and must be a string", code: "INVALID_INPUT" })
-      }
-      const params = inferFunctionParams(source_content, func_name)
-      return { params }
-    } catch (err) {
-      request.log.error(err, "tdd/params error")
-      return reply.code(500).send({ error: "Internal server error", code: "INTERNAL_ERROR" })
-    }
-  })
-
-  fastify.post("/api/v1/tdd/infer-type", async (request, reply) => {
-    try {
-      const { param_name, default_value } = request.body || {}
-      const type = inferTypeFromName(param_name, default_value)
-      return { type }
-    } catch (err) {
-      request.log.error(err, "tdd/infer-type error")
-      return reply.code(500).send({ error: "Internal server error", code: "INTERNAL_ERROR" })
-    }
-  })
-
-  fastify.post("/api/v1/tdd/skeleton", async (request, reply) => {
-    try {
-      const { language, file_name, exports, options } = request.body || {}
-      if (!exports || !Array.isArray(exports)) {
-        return reply.code(400).send({ error: "exports is required and must be an array", code: "INVALID_INPUT" })
-      }
-      if (exports.length === 0) {
-        return reply.code(400).send({ error: "exports array must not be empty", code: "INVALID_INPUT" })
-      }
-      if (!file_name || typeof file_name !== "string") {
-        return reply.code(400).send({ error: "file_name is required and must be a string", code: "INVALID_INPUT" })
-      }
-      const result = buildTestSkeleton(language || "javascript", file_name, exports, options || {})
-      return { skeleton: result }
-    } catch (err) {
-      request.log.error(err, "tdd/skeleton error")
-      return reply.code(500).send({ error: "Internal server error", code: "INTERNAL_ERROR" })
-    }
-  })
-}

package/routes/tier-routing.js

@@ -1,31 +0,0 @@
-import { classify, routeModel, isExploratoryPrompt } from "../lib/tier-routing.js"
-
-export async function tierRoutes(fastify) {
-  fastify.post("/api/v1/route/model", async (request, reply) => {
-    const { prompt, current_tier, trinity_cheap, trinity_medium, learned_exploratory, stress_score } = request.body || {}
-    if (!prompt) {
-      return reply.code(400).send({ error: "prompt is required" })
-    }
-    const learnedArr = Array.isArray(learned_exploratory) ? learned_exploratory : []
-    const result = routeModel(prompt, current_tier, trinity_cheap, trinity_medium, learnedArr, stress_score || 0)
-    return result
-  })
-
-  fastify.post("/api/v1/tier/classify", async (request, reply) => {
-    const { model, custom_regex } = request.body || {}
-    if (!model) {
-      return reply.code(400).send({ error: "model is required" })
-    }
-    const tier = classify(model, custom_regex)
-    return { model, tier }
-  })
-
-  fastify.post("/api/v1/tier/exploratory", async (request, reply) => {
-    const { prompt, learned_exploratory } = request.body || {}
-    if (!prompt) {
-      return reply.code(400).send({ error: "prompt is required" })
-    }
-    const result = isExploratoryPrompt(prompt, learned_exploratory || [])
-    return result
-  })
-}

package/scripts/dashboard-server.mjs

@@ -1,246 +0,0 @@
-#!/usr/bin/env node
-import http from "node:http"
-import { createReadStream, existsSync, statSync, readFileSync, readdirSync, writeFileSync, mkdirSync, renameSync } from "node:fs"
-import { extname, join, dirname } from "node:path"
-import { fileURLToPath } from "node:url"
-import { homedir } from "node:os"
-import crypto from "node:crypto"
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const ROOT = dirname(__dirname)
-const MIME_MAP = { ".html": "text/html; charset=utf-8", ".js": "application/javascript; charset=utf-8", ".css": "text/css; charset=utf-8", ".json": "application/json; charset=utf-8", ".png": "image/png", ".svg": "image/svg+xml", ".ico": "image/x-icon", ".map": "application/json" }
-const DASHBOARD_DIR = join(ROOT, "src", "dashboard", "dist")
-const STATE_DIR = join(homedir(), ".claude")
-const TIERS_FILE = join(STATE_DIR, "model-tiers.json")
-const STATE_FILE = join(STATE_DIR, "delegation-state.json")
-const REPORTS_DIR = join(STATE_DIR, "reports")
-const BACKEND_HEALTH_URL = process.env.VIBEOS_BACKEND_HEALTH_URL || "http://127.0.0.1:3000/health"
-const BACKEND_HEALTH_TTL_MS = 5_000
-
-let backendHealth = { ok: null, checkedAt: 0 }
-
-function rj(f) { try { if (!existsSync(f)) return null; return JSON.parse(readFileSync(f, "utf-8")) } catch { return null } }
-function wj(f, d) { try { mkdirSync(dirname(f), { recursive: true }); const t = f + ".tmp." + Date.now(); writeFileSync(t, JSON.stringify(d, null, 2) + "\n", "utf-8"); renameSync(t, f); return true } catch (e) { console.error("[vibeOS] write failed:", e.message); return false } }
-
-function checkAuth(req, res) {
-  return true
-}
-
-async function probeBackendHealth(force = false) {
-  const now = Date.now()
-  if (!force && backendHealth.ok !== null && (now - backendHealth.checkedAt) < BACKEND_HEALTH_TTL_MS) {
-    return backendHealth.ok
-  }
-  try {
-    const ctl = new AbortController()
-    const timer = setTimeout(() => ctl.abort(), 1500)
-    const res = await fetch(BACKEND_HEALTH_URL, { signal: ctl.signal })
-    clearTimeout(timer)
-    backendHealth = { ok: res.ok, checkedAt: now }
-    return res.ok
-  } catch {
-    backendHealth = { ok: false, checkedAt: now }
-    return false
-  }
-}
-
-function status() {
-  const t = rj(TIERS_FILE)
-  const s = rj(STATE_FILE)
-  const sel = t?.selection || {}
-  const activeSlot = sel.active_slot || "unknown"
-  const lockedSlot = sel.locked_slot || null
-  return {
-    enabled: sel.enabled !== false,
-    active_slot: activeSlot,
-    enforce: sel.delegation_enforce !== false,
-    flow_enforcer: sel.flow_enabled === true,
-    flow_extract_todos: sel.flow_enforce === true,
-    tdd_enforcer: sel.tdd_enforce === true,
-    tdd_strict: sel.tdd_strict !== false,
-    thinking: sel.thinking_level || "auto",
-    current_model: t?.trinity?.[activeSlot]?.oc || "unknown",
-    credit_percent: 0,
-    version: "0.13.6",
-    sessions_raw: s?.sessions || {},
-    backend_connected: backendHealth.ok === true,
-    backend_health_url: BACKEND_HEALTH_URL,
-    model_locked: sel.model_locked === true,
-    locked_slot: lockedSlot,
-    locked_model: sel.model_locked && lockedSlot ? (t?.trinity?.[lockedSlot]?.oc || "unknown") : null,
-  }
-}
-
-function savings() {
-  const s = rj(STATE_FILE)
-  const ses = Object.values(s?.sessions || {})
-  const lD = ses.reduce((a, e) => a + (e.warns || []).reduce((b, w) => b + (Number(w?.est_savings_usd) || 0), 0), 0)
-  const lC = ses.reduce((a, e) => a + (Number(e?.cache_savings_usd) || 0), 0)
-  const c = ses[ses.length - 1] || {}
-  const cW = c.warns || []
-  const cD = cW.reduce((a, w) => a + (Number(w?.est_savings_usd) || 0), 0)
-  const cC = Number(c?.cache_savings_usd) || 0
-  const bd = {}
-  cW.forEach(w => { const t = w.tool || "other"; bd[t] = (bd[t] || 0) + (Number(w?.est_savings_usd) || 0) })
-  return { lifetime: { delegation_usd: lD, cache_usd: lC, missed_context7_usd: 0, total_warns: ses.reduce((a, e) => a + (e.warns?.length || 0), 0) }, current_session: { delegation_usd: cD, cache_usd: cC, warns_count: cW.length, tool_breakdown: bd }, cache_hits_this_session: 0, trend: lD + lC > 0 ? "up" : "flat", savings_rate_per_hour: 0 }
-}
-
-function sessions() {
-  const m = rj(STATE_FILE)?.sessions || {}
-  const l = Object.entries(m).map(([id, e]) => ({ id, started: e?.started || null, cost_usd: Number(e?.cost_usd ?? 0) || 0, delegation_savings_usd: (e.warns || []).reduce((a, w) => a + (Number(w?.est_savings_usd) || 0), 0), cache_savings_usd: Number(e?.cache_savings_usd ?? 0) || 0, warns_count: (e.warns || []).length }))
-  return { sessions: l, total_sessions: l.length }
-}
-
-function reports() {
-  try {
-    if (!existsSync(REPORTS_DIR)) return []
-    return readdirSync(REPORTS_DIR).filter(f => f.endsWith(".json")).map(f => {
-      const d = rj(join(REPORTS_DIR, f))
-      return { id: f.replace(/\.json$/, ""), summary: d?.summary || "", type: d?.type || "", created: d?.created || "", tags: d?.tags || [] }
-    })
-  } catch {
-    return []
-  }
-}
-
-function report(id) { try { return rj(join(REPORTS_DIR, `${id}.json`)) } catch { return null } }
-
-function sf(res, fp, c) { const ext = extname(fp).toLowerCase(); const m = MIME_MAP[ext] || "application/octet-stream"; const st = statSync(fp); res.writeHead(200, { "Content-Type": m, "Content-Length": st.size, "Cache-Control": c ? "max-age=3600" : "no-cache", "Access-Control-Allow-Origin": process.env.DASHBOARD_ORIGIN || "http://localhost:" + (process.env.PORT || 3333) }); createReadStream(fp).pipe(res) }
-function dash(res, p) { if (p.includes("..")) { res.writeHead(404); res.end(); return } if (p === "/") { sf(res, join(DASHBOARD_DIR, "index.html"), false); return } const fp = join(DASHBOARD_DIR, "." + p); if (existsSync(fp) && statSync(fp).isFile()) { sf(res, fp, /\.(js|css|png|svg|ico)$/.test(p)) } else { res.writeHead(404); res.end() } }
-
-async function parseBody(req) { return new Promise((resolve) => { let raw = ""; req.on("data", c => { raw += String(c || ""); if (raw.length > 65536) { resolve(null) } }); req.on("end", () => { try { resolve(raw ? JSON.parse(raw) : {}) } catch { resolve(null) } }); req.on("error", () => resolve(null)) }) }
-
-function handleTrinity(body) {
-  if (!body || !body.action) return { ok: false, error: "missing action" }
-  const action = String(body.action)
-  const slot = body.slot ? String(body.slot) : null
-  const tiers = rj(TIERS_FILE)
-  if (!tiers) return { ok: false, error: "model-tiers.json not found" }
-  tiers.selection ??= {}
-
-  if (action === "set") {
-    if (slot && ["brain", "medium", "cheap"].includes(slot)) {
-      if (tiers.selection.model_locked && tiers.selection.locked_slot && tiers.selection.locked_slot !== slot) {
-        return { ok: false, error: `model is locked to ${tiers.selection.locked_slot}` }
-      }
-      tiers.selection.active_slot = slot
-      wj(TIERS_FILE, tiers)
-      return { ok: true, result: `Slot set to ${slot}` }
-    }
-    return { ok: false, error: "invalid slot" }
-  }
-  if (action === "lock") {
-    if (slot === "on") {
-      tiers.selection.model_locked = true
-      tiers.selection.locked_slot = tiers.selection.active_slot || "medium"
-      wj(TIERS_FILE, tiers)
-      return { ok: true, result: `Model locked to ${tiers.selection.locked_slot}` }
-    }
-    if (slot === "off") {
-      tiers.selection.model_locked = false
-      delete tiers.selection.locked_slot
-      wj(TIERS_FILE, tiers)
-      return { ok: true, result: "Model lock disabled" }
-    }
-    return { ok: false, error: "invalid lock slot" }
-  }
-  if (action === "enforce") {
-    tiers.selection.delegation_enforce = slot === "on"
-    wj(TIERS_FILE, tiers)
-    return { ok: true, result: `Enforcement ${slot === "on" ? "ON" : "OFF"}` }
-  }
-  if (action === "flow") {
-    if (slot === "on" || slot === "off") {
-      tiers.selection.flow_enabled = slot === "on"
-      wj(TIERS_FILE, tiers)
-      return { ok: true, result: `Flow ${slot.toUpperCase()}` }
-    }
-    if (slot === "enforce") {
-      const cur = tiers.selection.flow_enforce === true
-      tiers.selection.flow_enforce = !cur
-      wj(TIERS_FILE, tiers)
-      return { ok: true, result: `Flow enforce ${cur ? "OFF" : "ON"}` }
-    }
-    return { ok: false, error: "invalid flow slot" }
-  }
-  if (action === "tdd") {
-    if (slot === "on" || slot === "off") {
-      tiers.selection.tdd_enforce = slot === "on"
-      wj(TIERS_FILE, tiers)
-      return { ok: true, result: `TDD ${slot.toUpperCase()}` }
-    }
-    if (slot === "strict") {
-      const cur = tiers.selection.tdd_strict === true
-      tiers.selection.tdd_strict = !cur
-      wj(TIERS_FILE, tiers)
-      return { ok: true, result: `TDD strict ${cur ? "OFF" : "ON"}` }
-    }
-    return { ok: false, error: "invalid tdd slot" }
-  }
-  if (action === "thinking") {
-    if (["full", "brief", "off"].includes(String(slot))) {
-      tiers.selection.thinking_level = String(slot)
-      wj(TIERS_FILE, tiers)
-      return { ok: true, result: `Thinking set to ${slot}` }
-    }
-    return { ok: false, error: "invalid thinking level" }
-  }
-  if (action === "disable") {
-    tiers.selection.enabled = false
-    wj(TIERS_FILE, tiers)
-    return { ok: true, result: "vibeOS disabled" }
-  }
-  if (action === "status" || action === "diagnose" || action === "project" || action === "help") {
-    return { ok: true, result: `${action} ok` }
-  }
-  return { ok: false, error: "unknown action" }
-}
-
-const SSE = new Set()
-let si = null
-
-async function bcast() {
-  await probeBackendHealth()
-  const d = JSON.stringify({ status: status(), savings: savings() })
-  for (const r of SSE) { try { r.write(`data: ${d}\n\n`) } catch { SSE.delete(r) } }
-}
-
-async function hSSE(req, res) {
-  await probeBackendHealth()
-  res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive", "Access-Control-Allow-Origin": process.env.DASHBOARD_ORIGIN || "http://localhost:" + (process.env.PORT || 3333) })
-  res.write(`data: ${JSON.stringify({ status: status(), savings: savings() })}\n\n`)
-  SSE.add(res)
-  if (!si) si = setInterval(() => { void bcast() }, 1500)
-  req.on("close", () => { SSE.delete(res); if (SSE.size === 0 && si) { clearInterval(si); si = null } })
-}
-
-async function main() {
-  const PORT = Number(process.env.PORT || 3333)
-  if (!existsSync(join(DASHBOARD_DIR, "index.html"))) { console.error("[vibeOS] Dashboard not built. Run: npm run build:dashboard"); process.exit(1) }
-  const s = http.createServer(async (req, res) => {
-    res.setHeader("Access-Control-Allow-Origin", process.env.DASHBOARD_ORIGIN || "http://localhost:" + (process.env.PORT || 3333))
-    if (req.method === "OPTIONS") { res.writeHead(204, { "Access-Control-Allow-Methods": "GET,POST,OPTIONS", "Access-Control-Allow-Headers": "Content-Type,Authorization", "Access-Control-Allow-Credentials": "true" }); res.end(); return }
-    const p = new URL(req.url, `http://127.0.0.1:${PORT}`).pathname
-    try {
-      if (p === "/status") { if (!checkAuth(req, res)) return; await probeBackendHealth(); res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify(status())); return }
-      if (p === "/savings") { if (!checkAuth(req, res)) return; res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify(savings())); return }
-      if (p === "/sessions") { if (!checkAuth(req, res)) return; res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify(sessions())); return }
-      if (p === "/reports") { if (!checkAuth(req, res)) return; res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify(reports())); return }
-      if (p.startsWith("/reports/")) { if (!checkAuth(req, res)) return; const id = decodeURIComponent(p.replace("/reports/", "")); const r = report(id); if (r) { res.writeHead(200, { "Content-Type": "application/json" }); res.end(JSON.stringify(r)) } else { res.writeHead(404); res.end() }; return }
-      if (p === "/events") { if (!checkAuth(req, res)) return; await hSSE(req, res); return }
-      if (p === "/trinity" && req.method === "POST") {
-        if (!checkAuth(req, res)) return
-        const body = await parseBody(req)
-        const result = handleTrinity(body)
-        res.writeHead(result.ok ? 200 : 400, { "Content-Type": "application/json" })
-        res.end(JSON.stringify(result))
-        void bcast()
-        return
-      }
-      dash(res, p)
-    } catch (e) { res.writeHead(500); res.end(e.message) }
-  })
-  s.listen(PORT, "127.0.0.1", () => { const a = s.address(); const ap = typeof a === "object" && a ? a.port : PORT; console.error(`[vibeOS] Dashboard server on http://127.0.0.1:${ap}\n[vibeOS] Open http://127.0.0.1:${ap}/ in your browser`) })
-}
-
-main()

package/scripts/deploy-zero-downtime.sh

@@ -1,77 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-VPS_HOST="${VPS_HOST:-45.132.242.217}"
-VPS_USER="${VPS_USER:-root}"
-BASE="/var/www/vibeos-api"
-REL="$BASE/releases/$(date +%s)"
-CUR="$BASE/current"
-P1=3000
-P2=3001
-NGX="/etc/nginx/sites-enabled/vibeos-api.conf"
-
-log() { echo "  [$1] $2"; }
-r() { ssh "$VPS_USER@$VPS_HOST" "$@"; }
-pid() { r "lsof -ti :$1 2>/dev/null || true"; }
-up() { r "curl -sf -o /dev/null http://127.0.0.1:$1/health" 2>/dev/null; return $?; }
-
-echo "[vibeOS-api] Zero-downtime deploy"
-
-# 1. Upload
-log "deploy" "Creating release dir..."
-r "mkdir -p $REL/data"
-
-log "deploy" "Uploading files..."
-D="$(dirname "$0")/.."
-for f in server.js start.sh lib routes middleware package.json; do
-  [ -e "$D/$f" ] && scp -qr "$D/$f" "$VPS_USER@$VPS_HOST:$REL/"
-done
-
-log "deps" "npm install..."
-r "cd $REL && npm install --omit=dev --silent 2>/dev/null"
-
-# 2. .env
-log "env" "Copying .env..."
-r "cp $BASE/.env $REL/.env 2>/dev/null || cp $CUR/.env $REL/.env 2>/dev/null ||:"
-
-# 3. Blue-green port detection
-CUR_P=""; NEW_P=""
-up $P1 && CUR_P=$P1 && NEW_P=$P2 || true
-up $P2 && CUR_P=$P2 && NEW_P=$P1 || true
-[ -z "$CUR_P" ] && NEW_P=$P1 && log "deploy" "Fresh start on $NEW_P" || log "deploy" "Instance on $CUR_P, deploying to $NEW_P"
-
-# 4. Start new instance (detached via ssh -f)
-log "start" "Starting on port $NEW_P..."
-r "cd $REL && screen -dmS vibeos-$NEW_P env PORT=$NEW_P bash start.sh"
-sleep 3
-
-# 5. Health check
-log "health" "Waiting for port $NEW_P..."
-for i in $(seq 1 15); do
-  up $NEW_P && log "health" "OK after ${i}s" && break || true
-  [ $i -eq 15 ] && log "health" "FAIL" && r "screen -S vibeos-$NEW_P -X quit 2>/dev/null; true" && exit 1
-  sleep 1
-done
-
-# 6. Swap nginx
-log "nginx" "Switching to port $NEW_P..."
-r "sed -i 's|proxy_pass http://127.0.0.1:[0-9]*|proxy_pass http://127.0.0.1:$NEW_P|g' $NGX"
-r "nginx -t && systemctl reload nginx"
-
-# 7. Kill old
-if [ -n "$CUR_P" ]; then
-  O=$(pid $CUR_P)
-  [ -n "$O" ] && log "stop" "Stopping old PID $O" && r "kill $O 2>/dev/null; sleep 2; kill -9 $O 2>/dev/null; true"
-fi
-
-# 8. Symlink + systemd
-log "symlink" "$CUR -> $REL"
-r "ln -sfn $REL $CUR && cp $REL/start.sh $BASE/start.sh"
-r "sed -i 's|WorkingDirectory=.*|WorkingDirectory=$CUR|' /etc/systemd/system/vibeos-api.service 2>/dev/null; systemctl daemon-reload 2>/dev/null; true"
-
-# 9. Cleanup
-log "cleanup" "Keeping last 3 releases..."
-r "ls -1d $BASE/releases/*/ 2>/dev/null | sort -r | tail -n +4 | xargs rm -rf 2>/dev/null; true"
-
-echo
-echo "[vibeOS-api] Done! Port $NEW_P | https://api.vibetheog.com/health"

package/scripts/deploy.sh

@@ -1,68 +0,0 @@
-#!/bin/bash
-set -e
-
-echo "[vibeOS-api] Deploying API server to VPS..."
-
-VPS_HOST="${VPS_HOST:-45.132.242.217}"
-VPS_USER="${VPS_USER:-root}"
-DEPLOY_DIR="/var/www/vibeos-api"
-
-echo "[1/7] Checking SSH connection to $VPS_HOST..."
-ssh -o ConnectTimeout=10 "$VPS_USER@$VPS_HOST" "echo 'SSH OK'" || {
-  echo "ERROR: Cannot connect to VPS at $VPS_HOST"
-  exit 1
-}
-
-echo "[2/7] Installing Node.js on VPS..."
-ssh "$VPS_USER@$VPS_HOST" bash << 'EOF'
-  if ! command -v node &>/dev/null; then
-    curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
-    apt-get install -y nodejs
-  fi
-  echo "Node.js $(node --version) installed"
-EOF
-
-echo "[3/7] Creating deploy directory..."
-ssh "$VPS_USER@$VPS_HOST" "mkdir -p $DEPLOY_DIR/data"
-
-echo "[4/7] Uploading API server files..."
-scp -r "$(dirname "$0")/../server.js" \
-      "$(dirname "$0")/../lib/" \
-      "$(dirname "$0")/../routes/" \
-      "$(dirname "$0")/../middleware/" \
-      "$(dirname "$0")/../package.json" \
-      "$VPS_USER@$VPS_HOST:$DEPLOY_DIR/"
-
-echo "[5/7] Installing dependencies..."
-ssh "$VPS_USER@$VPS_HOST" "cd $DEPLOY_DIR && npm install --production"
-
-echo "[6/7] Setting up systemd service..."
-scp "$(dirname "$0")/../vibeos-api.service" "$VPS_USER@$VPS_HOST:/tmp/vibeos-api.service"
-ssh "$VPS_USER@$VPS_HOST" bash << EOF
-  cp /tmp/vibeos-api.service /etc/systemd/system/vibeos-api.service
-  systemctl daemon-reload
-  systemctl enable vibeos-api
-  systemctl restart vibeos-api
-  rm /tmp/vibeos-api.service
-EOF
-
-echo "[7/7] Setting up Nginx reverse proxy..."
-scp "$(dirname "$0")/../nginx-vibetheog-api.conf" "$VPS_USER@$VPS_HOST:/tmp/vibeos-api-nginx.conf"
-ssh "$VPS_USER@$VPS_HOST" bash << 'EOF'
-  cp /tmp/vibeos-api-nginx.conf /etc/nginx/sites-available/vibeos-api.conf
-  ln -sf /etc/nginx/sites-available/vibeos-api.conf /etc/nginx/sites-enabled/
-  nginx -t && systemctl reload nginx
-  rm /tmp/vibeos-api-nginx.conf
-EOF
-
-echo ""
-echo "[vibeOS-api] Deployment complete!"
-echo "  API URL: https://api.vibetheog.com"
-echo "  Health:  https://api.vibetheog.com/health"
-echo ""
-echo "Next steps:"
-echo "  1. SSH into VPS and create .env file: cp $DEPLOY_DIR/.env.example $DEPLOY_DIR/.env"
-echo "  2. Set VIBEOS_API_MASTER_KEY in .env"
-echo "  3. Run: cd $DEPLOY_DIR && npm run seed"
-echo "  4. Add DNS record: api.vibetheog.com -> $VPS_HOST"
-echo "  5. Run: certbot --nginx -d api.vibetheog.com"

package/scripts/release.mjs

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-import { execSync } from "node:child_process"
-import { readFileSync, writeFileSync } from "node:fs"
-import { resolve, dirname } from "node:path"
-import { fileURLToPath } from "node:url"
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const ROOT = resolve(__dirname, "..")
-
-const args = process.argv.slice(2)
-const isCI = args.includes("--ci")
-const bumpType = args.find(a => ["patch","minor","major"].includes(a)) || "patch"
-
-const pkgPath = resolve(ROOT, "package.json")
-const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"))
-const [major, minor, patch] = pkg.version.split(".").map(Number)
-
-let newVersion
-if (bumpType === "major") newVersion = `${major + 1}.0.0`
-else if (bumpType === "minor") newVersion = `${major}.${minor + 1}.0`
-else newVersion = `${major}.${minor}.${patch + 1}`
-
-pkg.version = newVersion
-writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n")
-
-if (isCI) {
-  execSync(`git add package.json`, { cwd: ROOT, stdio: "inherit" })
-}
-
-console.log(`[vibeOScore] Version bumped to ${newVersion}`)

package/scripts/seed-master-token.js

@@ -1,29 +0,0 @@
-import { getDb, initDb } from "../lib/db.js"
-import { randomBytes } from "node:crypto"
-
-const MASTER_KEY = process.env.VIBEOS_API_MASTER_KEY || randomBytes(32).toString("hex")
-const SEAT_NAME = process.env.SEAT_NAME || "vibeOS Default"
-const SEAT_EMAIL = process.env.SEAT_EMAIL || ""
-
-initDb()
-const db = getDb()
-
-const existing = db.prepare("SELECT COUNT(*) as count FROM seats").get()
-if (existing.count > 0) {
-  console.log("[seed] Database already has seats, skipping")
-  process.exit(0)
-}
-
-const seatResult = db.prepare("INSERT INTO seats (name, email) VALUES (?, ?)").run(SEAT_NAME, SEAT_EMAIL || null)
-console.log(`[seed] Created seat: ${SEAT_NAME} (id: ${seatResult.lastInsertRowid})`)
-
-const token = "vos_" + randomBytes(32).toString("hex")
-const tokenResult = db.prepare("INSERT INTO api_tokens (token, seat_id, label) VALUES (?, ?, ?)").run(token, seatResult.lastInsertRowid, "default")
-
-console.log(`[seed] Created API token: ${token}`)
-console.log(`[seed] Master key: ${MASTER_KEY}`)
-console.log("")
-console.log("IMPORTANT: Save these credentials!")
-console.log(`  VIBEOS_API_MASTER_KEY=${MASTER_KEY}`)
-console.log(`  VIBEOS_API_TOKEN=${token}`)
-console.log(`  API_URL=http://localhost:3000`)