@worca/ui 0.1.0-rc.5 → 0.1.0-rc.6

package/app/styles.css

@@ -3895,3 +3895,22 @@ sl-details.learnings-panel::part(content) {
   color: var(--fg);
 }
 
+/* ─── Version info rows ─────────────────────────────────────────────── */
+.version-row { display: flex; align-items: center; padding: 4px 0; gap: 8px; }
+.version-row-label { font-size: 12px; color: var(--muted); white-space: nowrap; min-width: 64px; }
+.version-row-value { font-size: 13px; font-weight: 500; color: var(--fg); font-family: var(--sl-font-mono); white-space: nowrap; margin-left: auto; display: flex; align-items: center; gap: 6px; }
+.settings-card-header > sl-badge { margin-left: auto; }
+.version-title-exact { text-transform: none; }
+.version-copy-btn {
+  background: none; border: 1px solid var(--border); border-radius: 4px;
+  padding: 2px 4px; cursor: pointer; color: var(--muted);
+  display: inline-flex; align-items: center; margin-left: 4px;
+  transition: var(--transition-fast);
+}
+.version-copy-btn:hover { background: var(--bg-tertiary); color: var(--fg); }
+.version-copy-icon { display: inline-flex; align-items: center; min-width: 12px; }
+.version-refresh { display: flex; align-items: center; gap: 8px; margin-top: 8px; }
+.version-refresh-hint { font-size: 11px; color: var(--muted); }
+.project-worca-version { font-size: 11px; color: var(--muted); font-family: var(--sl-font-mono); margin-top: 2px; }
+.project-worca-version--behind { color: var(--status-failed, #dc2626); }
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/ui",
-  "version": "0.1.0-rc.5",
+  "version": "0.1.0-rc.6",
   "description": "Pipeline monitoring UI for worca-cc",
   "license": "MIT",
   "author": "Sinisha Djukic",

package/server/app.js

@@ -13,6 +13,7 @@ import {
   createProjectScopedRoutes,
   projectResolver,
 } from './project-routes.js';
+import { getVersionInfo } from './versions.js';
 import { createInbox } from './webhook-inbox.js';
 
 export function createApp(options = {}) {
@@ -403,6 +404,19 @@ export function createApp(options = {}) {
     }
   });
 
+  // GET /api/versions — installed + registry version info
+  app.get('/api/versions', async (req, res) => {
+    const force = req.query.force === '1';
+    const prefsPath = prefsDir ? join(prefsDir, 'preferences.json') : null;
+    const worcaVersion = app.locals.worcaVersion || null;
+    try {
+      const data = await getVersionInfo({ prefsPath, worcaVersion, force });
+      res.json(data);
+    } catch (err) {
+      res.status(500).json({ ok: false, error: err.message });
+    }
+  });
+
   // ─── Multi-project routes ──────────────────────────────────────────────
   if (prefsDir) {
     app.use('/api/projects', createProjectRoutes({ prefsDir, projectRoot }));

package/server/preferences.js

@@ -1,7 +1,7 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 
-const DEFAULTS = { theme: 'light', source_repo: '' };
+const DEFAULTS = { theme: 'light', source_repo: '', notifications: null };
 
 export function readPreferences(path) {
   try {

package/server/project-routes.js

@@ -37,7 +37,11 @@ import {
 } from './settings-merge.js';
 import { validateSettingsPayload } from './settings-validator.js';
 import { discoverRuns } from './watcher.js';
-import { checkWorcaInstalled, runWorcaSetup } from './worca-setup.js';
+import {
+  checkWorcaInstalled,
+  readProjectWorcaVersion,
+  runWorcaSetup,
+} from './worca-setup.js';
 
 /** Validate a runId — must not contain path traversal characters */
 const RUN_ID_RE = /^[a-zA-Z0-9_-]+$/;
@@ -133,13 +137,16 @@ export function createProjectRoutes({ prefsDir, projectRoot }) {
 
   // GET /api/projects — list all projects (or synthesized default)
   router.get('/', (_req, res) => {
-    const projects = readProjects(prefsDir);
-    if (projects.length > 0) {
-      return res.json({ ok: true, projects });
-    }
-    // No registered projects — synthesize from cwd
-    const synth = synthesizeDefaultProject(projectRoot);
-    res.json({ ok: true, projects: [synth] });
+    let projects = readProjects(prefsDir);
+    if (projects.length === 0) {
+      projects = [synthesizeDefaultProject(projectRoot)];
+    }
+    // Enrich each project with its worca-cc version
+    const enriched = projects.map((p) => ({
+      ...p,
+      worcaVersion: readProjectWorcaVersion(p.path),
+    }));
+    res.json({ ok: true, projects: enriched });
   });
 
   // POST /api/projects — create a new project
@@ -203,7 +210,17 @@ export function createProjectScopedRoutes() {
   router.get('/runs', requireWorcaDir, (req, res) => {
     try {
       const runs = discoverRuns(req.project.worcaDir);
-      res.json({ ok: true, runs });
+      const response = { ok: true, runs };
+      // Include settings so multi-project clients can use loop limits, etc.
+      const { settingsPath } = req.project;
+      if (settingsPath && existsSync(settingsPath)) {
+        try {
+          response.settings = readMergedSettings(settingsPath);
+        } catch {
+          /* non-fatal — runs still returned */
+        }
+      }
+      res.json(response);
     } catch (err) {
       res.status(500).json({ ok: false, error: err.message });
     }

package/server/versions.js

@@ -0,0 +1,260 @@
+// server/versions.js — version fetching + caching for worca-cc and @worca/ui
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readPreferences } from './preferences.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/** Cache: { data, timestamp } */
+let _cache = null;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Compare two semver-ish strings. Returns -1, 0, or 1.
+ * Strips pre-release suffixes for comparison (e.g. "rc", "dev", "alpha").
+ * @param {string} a
+ * @param {string} b
+ * @returns {number}
+ */
+export function compareVersions(a, b) {
+  if (!a || !b) return 0;
+  const parse = (v) =>
+    v.split('.').map((s) => {
+      const n = parseInt(s, 10);
+      return Number.isNaN(n) ? 0 : n;
+    });
+  const pa = parse(a);
+  const pb = parse(b);
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const x = pa[i] || 0;
+    const y = pb[i] || 0;
+    if (x > y) return 1;
+    if (x < y) return -1;
+  }
+  return 0;
+}
+
+/**
+ * Parse a PyPI pre-release version like "0.6.0rc7" → { base: "0.6.0", rc: 7 }
+ * Returns null if not an RC version.
+ * @param {string} versionStr
+ * @returns {{ base: string, rc: number } | null}
+ */
+export function parsePyPIPreRelease(versionStr) {
+  const match = versionStr.match(/^(.+?)rc(\d+)$/);
+  if (!match) return null;
+  return { base: match[1], rc: parseInt(match[2], 10) };
+}
+
+/**
+ * Fetch latest + latestRc versions from npm registry.
+ * @param {string} packageName
+ * @returns {Promise<{ latest: string|null, latestRc: string|null }>}
+ */
+export async function fetchNpmVersions(packageName) {
+  const nullResult = { latest: null, latestRc: null };
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 3000);
+    let res;
+    try {
+      res = await fetch(`https://registry.npmjs.org/${packageName}`, {
+        signal: controller.signal,
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) return nullResult;
+    const data = await res.json();
+    const latest = data['dist-tags']?.latest || null;
+    let latestRc = data['dist-tags']?.rc || null;
+    if (!latestRc && data.versions) {
+      // Scan version keys for highest *-rc.* pattern
+      let bestRc = null;
+      let bestRcNum = -1;
+      for (const ver of Object.keys(data.versions)) {
+        const rcMatch = ver.match(/^(.+)-rc\.(\d+)$/);
+        if (rcMatch) {
+          const rcNum = parseInt(rcMatch[2], 10);
+          const base = rcMatch[1];
+          // Compare base+rcNum to find the highest RC
+          if (
+            !bestRc ||
+            compareVersions(base, bestRc.base) > 0 ||
+            (compareVersions(base, bestRc.base) === 0 && rcNum > bestRcNum)
+          ) {
+            bestRc = { base, full: ver };
+            bestRcNum = rcNum;
+          }
+        }
+      }
+      if (bestRc) latestRc = bestRc.full;
+    }
+    return { latest, latestRc };
+  } catch {
+    return nullResult;
+  }
+}
+
+/**
+ * Fetch latest + latestRc versions from PyPI.
+ * @param {string} packageName
+ * @returns {Promise<{ latest: string|null, latestRc: string|null }>}
+ */
+export async function fetchPyPIVersions(packageName) {
+  const nullResult = { latest: null, latestRc: null };
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 3000);
+    let res;
+    try {
+      res = await fetch(`https://pypi.org/pypi/${packageName}/json`, {
+        signal: controller.signal,
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) return nullResult;
+    const data = await res.json();
+    const latest = data.info?.version || null;
+    // Scan releases for highest rc version
+    let latestRc = null;
+    if (data.releases) {
+      let bestRcNum = -1;
+      let bestBase = null;
+      for (const ver of Object.keys(data.releases)) {
+        const parsed = parsePyPIPreRelease(ver);
+        if (parsed) {
+          if (
+            !bestBase ||
+            compareVersions(parsed.base, bestBase) > 0 ||
+            (compareVersions(parsed.base, bestBase) === 0 &&
+              parsed.rc > bestRcNum)
+          ) {
+            bestBase = parsed.base;
+            bestRcNum = parsed.rc;
+            latestRc = ver;
+          }
+        }
+      }
+    }
+    return { latest, latestRc };
+  } catch {
+    return nullResult;
+  }
+}
+
+/**
+ * Read versions from local dev path.
+ * @param {string} sourceRepo - path to local worca-cc repo
+ * @returns {{ worcaCc: string|null, worcaUi: string|null }}
+ */
+export function getDevPathVersions(sourceRepo) {
+  const result = { worcaCc: null, worcaUi: null };
+  if (!sourceRepo) return result;
+  try {
+    const pyproject = readFileSync(join(sourceRepo, 'pyproject.toml'), 'utf8');
+    const match = pyproject.match(/^version\s*=\s*"([^"]+)"/m);
+    if (match) result.worcaCc = match[1];
+  } catch {
+    // pyproject.toml not found or unreadable
+  }
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(sourceRepo, 'worca-ui', 'package.json'), 'utf8'),
+    );
+    if (pkg.version) result.worcaUi = pkg.version;
+  } catch {
+    // package.json not found or unreadable
+  }
+  return result;
+}
+
+/**
+ * Get installed @worca/ui version from own package.json.
+ * @returns {string|null}
+ */
+function getInstalledUiVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(join(__dirname, '..', 'package.json'), 'utf8'),
+    );
+    return pkg.version || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Main orchestrator: fetch all version info with caching.
+ * @param {{ prefsPath?: string|null, worcaVersion?: object|null, force?: boolean }} options
+ * @returns {Promise<object>}
+ */
+export async function getVersionInfo({ prefsPath, worcaVersion, force } = {}) {
+  // Return cached result if fresh
+  if (!force && _cache && Date.now() - _cache.timestamp < CACHE_TTL_MS) {
+    return _cache.data;
+  }
+
+  // Read source_repo from preferences
+  let sourceRepo = null;
+  if (prefsPath) {
+    const prefs = readPreferences(prefsPath);
+    sourceRepo = prefs.source_repo || null;
+  }
+
+  // Fetch in parallel
+  const [npmResult, pypiResult] = await Promise.allSettled([
+    fetchNpmVersions('@worca/ui'),
+    fetchPyPIVersions('worca-cc'),
+  ]);
+
+  const npm =
+    npmResult.status === 'fulfilled'
+      ? npmResult.value
+      : { latest: null, latestRc: null };
+  const pypi =
+    pypiResult.status === 'fulfilled'
+      ? pypiResult.value
+      : { latest: null, latestRc: null };
+
+  // Dev path versions
+  const devVersions = sourceRepo ? getDevPathVersions(sourceRepo) : null;
+
+  // Installed versions
+  const installedUi = getInstalledUiVersion();
+  const installedCc = worcaVersion?.installed || null;
+
+  const data = {
+    ok: true,
+    worcaCc: {
+      installed: installedCc,
+      latest: pypi.latest,
+      latestRc: pypi.latestRc,
+    },
+    worcaUi: {
+      installed: installedUi,
+      latest: npm.latest,
+      latestRc: npm.latestRc,
+    },
+    devPath: devVersions
+      ? {
+          path: sourceRepo,
+          worcaCc: devVersions.worcaCc,
+          worcaUi: devVersions.worcaUi,
+        }
+      : null,
+    activeWorcaCc: devVersions?.worcaCc || installedCc,
+    cachedAt: new Date().toISOString(),
+  };
+
+  _cache = { data, timestamp: Date.now() };
+  return data;
+}
+
+/** Clear the cache (for testing). */
+export function clearCache() {
+  _cache = null;
+}

package/server/worca-setup.js

@@ -9,7 +9,7 @@
  */
 
 import { spawn } from 'node:child_process';
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 
 /**
@@ -19,6 +19,23 @@ export function checkWorcaInstalled(projectPath) {
   return existsSync(join(projectPath, '.claude', 'worca'));
 }
 
+/**
+ * Read the worca-cc version from a project's .claude/worca/__init__.py.
+ * Returns the version string or null if not found.
+ */
+export function readProjectWorcaVersion(projectPath) {
+  try {
+    const initPy = readFileSync(
+      join(projectPath, '.claude', 'worca', '__init__.py'),
+      'utf8',
+    );
+    const match = initPy.match(/^__version__\s*=\s*["']([^"']+)["']/m);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Spawn `worca init --upgrade` in the target project directory.
  * Optionally passes --source if a source repo path is provided.