npm - groove-dev - Versions diffs - 0.27.197 → 0.27.198 - Mend

groove-dev 0.27.197 → 0.27.198

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/node_modules/@groove-dev/gui/dist/index.html CHANGED Viewed

@@ -6,12 +6,12 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="icon" type="image/png" href="/favicon.png" />
     <title>Groove GUI</title>
-    <script type="module" crossorigin src="/assets/index-Da2nbd6M.js"></script>
+    <script type="module" crossorigin src="/assets/index-b9dKN6cq.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/vendor-26L3JoZv.js">
     <link rel="modulepreload" crossorigin href="/assets/reactflow-DoBZjiHE.js">
     <link rel="modulepreload" crossorigin href="/assets/codemirror-BYKpdS2W.js">
     <link rel="modulepreload" crossorigin href="/assets/xterm--7_ns2zW.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-zmrIbwNm.css">
+    <link rel="stylesheet" crossorigin href="/assets/index-RbtaI6l7.css">
   </head>
   <body>
     <div id="root"></div>

package/node_modules/@groove-dev/gui/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@groove-dev/gui",
-  "version": "0.27.197",
+  "version": "0.27.198",
   "description": "GROOVE GUI — visual agent control plane",
   "license": "FSL-1.1-Apache-2.0",
   "type": "module",

package/node_modules/@groove-dev/gui/src/App.jsx CHANGED Viewed

@@ -25,6 +25,7 @@ import NetworkView from './views/network';
 import MemoryView from './views/memory';
 import FleetView from './views/fleet';
 import AutoAgentsView from './views/auto-agents';
+import AxomView from './views/axom';
 // Agent components
 import { AgentPanel } from './components/agents/agent-panel';
@@ -79,6 +80,7 @@ function ViewRouter() {
     case 'federation':  content = <FederationView />;  break;
     case 'settings':    content = <SettingsView />;    break;
     case 'fleet':       content = <FleetView />;       break;
+    case 'axom':        content = <AxomView />;        break;
     case 'memory':      content = <MemoryView />;      break;
     case 'network':     content = networkUnlocked ? <NetworkView /> : <AgentsView />; break;
     default:            content = <AgentsView />;

package/node_modules/@groove-dev/gui/src/app.css CHANGED Viewed

@@ -309,6 +309,59 @@ html {
   box-shadow: 0 0 60px rgba(51,175,188,0.15), 0 0 120px rgba(51,175,188,0.04);
 }
+/* ── Axom Onboarding ─────────────────────────────────────── */
+/* Front door backdrop — one cool bloom behind the mark on the identity pane,
+   a faint cold wash under the operations pane. Nothing else. */
+.axom-hero-bg {
+  background:
+    radial-gradient(ellipse 760px 620px at 20% 38%, rgba(51, 175, 188, 0.11) 0%, transparent 68%),
+    radial-gradient(ellipse 900px 700px at 88% 62%, rgba(122, 176, 223, 0.045) 0%, transparent 70%),
+    var(--color-surface-1);
+}
+/* Panels read as instrument faces: light at the top edge, settling downward. */
+.axom-panel {
+  background: linear-gradient(180deg, var(--color-surface-3) 0%, var(--color-surface-1) 100%);
+}
+/* Hairline that carries the accent only where it matters — a top edge. */
+.axom-edge-accent {
+  background: linear-gradient(90deg, transparent 0%, rgba(51, 175, 188, 0.6) 50%, transparent 100%);
+}
+.axom-edge-muted {
+  background: linear-gradient(90deg, transparent 0%, var(--color-border) 50%, transparent 100%);
+}
+/* Display type — a soft vertical falloff, no color, just depth. */
+.axom-display {
+  background: linear-gradient(180deg, #f2f4f7 0%, #9aa3b0 100%);
+  -webkit-background-clip: text;
+  background-clip: text;
+  color: transparent;
+}
+.axom-ring {
+  border-radius: 50%;
+  border: 1px solid rgba(51, 175, 188, 0.22);
+}
+@keyframes axom-orbit { to { transform: rotate(360deg); } }
+.animate-axom-orbit { animation: axom-orbit 26s linear infinite; }
+.animate-axom-orbit-slow { animation: axom-orbit 44s linear infinite reverse; }
+@keyframes axom-breathe {
+  0%, 100% { opacity: 0.45; }
+  50%      { opacity: 0.85; }
+}
+.animate-axom-breathe { animation: axom-breathe 6s ease-in-out infinite; }
+@media (prefers-reduced-motion: reduce) {
+  .animate-axom-orbit,
+  .animate-axom-orbit-slow,
+  .animate-axom-breathe { animation: none; }
+}
 /* ── React Flow Overrides ─────────────────────────────────── */
 /* Suppress node fly-in animation — nodes appear in position instantly */

package/node_modules/@groove-dev/gui/src/components/layout/activity-bar.jsx CHANGED Viewed

@@ -1,5 +1,5 @@
 // FSL-1.1-Apache-2.0 — see LICENSE
-import { Network, Code2, ChartSpline, Puzzle, Users, Box, FlaskConical, Newspaper, Settings, Globe, BookOpen, LayoutList, Bot } from 'lucide-react';
+import { Network, Code2, ChartSpline, Puzzle, Users, Box, FlaskConical, Newspaper, Settings, Globe, BookOpen, LayoutList, Bot, Atom } from 'lucide-react';
 import { cn } from '../../lib/cn';
 import { Tooltip } from '../ui/tooltip';
 import { useGrooveStore } from '../../stores/groove';
@@ -7,6 +7,7 @@ import { isElectron, getPlatform } from '../../lib/electron';
 const BASE_NAV_ITEMS = [
   { id: 'agents',      icon: Network,       label: 'Agents' },
+  { id: 'axom',        icon: Atom,          label: 'Axom' },
   { id: 'fleet',       icon: LayoutList,    label: 'Fleet' },
   { id: 'editor',      icon: Code2,         label: 'Editor' },
   { id: 'dashboard',   icon: ChartSpline,   label: 'Dashboard' },

package/node_modules/@groove-dev/gui/src/stores/groove.js CHANGED Viewed

@@ -14,6 +14,7 @@ import { createPreviewSlice } from './slices/preview-slice.js';
 import { createMarketplaceSlice } from './slices/marketplace-slice.js';
 import { createAutomationsSlice } from './slices/automations-slice.js';
 import { createAutoAgentsSlice } from './slices/auto-agents-slice.js';
+import { createAxomSlice } from './slices/axom-slice.js';
 const WS_URL = `ws://${window.location.hostname}:${window.location.port || 31415}`;
@@ -39,6 +40,7 @@ export const useGrooveStore = create((set, get) => ({
   ...createMarketplaceSlice(set, get),
   ...createAutomationsSlice(set, get),
   ...createAutoAgentsSlice(set, get),
+  ...createAxomSlice(set, get),
   // ── Connection ────────────────────────────────────────────
   connected: false,
@@ -73,6 +75,7 @@ export const useGrooveStore = create((set, get) => ({
       get().fetchTunnels();
       get().fetchBetaStatus();
       get().fetchNetworkInstallStatus();
+      get().fetchAxomStatus();
       get().fetchTrainingStatus();
       api.get('/config').then((cfg) => {
         if (cfg?.dataSharingDismissed) set({ dataSharingDismissed: true });
@@ -653,6 +656,22 @@ export const useGrooveStore = create((set, get) => ({
           set({ gateways: msg.data || [] });
           break;
+        case 'axom:status':
+          set({ axomStatus: msg.data || { endpoints: [] } });
+          break;
+        case 'axom:event':
+          get().ingestAxomEvent(msg.endpoint, msg.session, msg.envelope);
+          break;
+        case 'axom:instances':
+          set({ axomInstances: msg.data || [] });
+          break;
+        case 'axom:install:progress':
+          set({ axomInstall: msg.data });
+          break;
         case 'provider:status-changed':
           set({ _providerRefreshTick: Date.now() });
           break;

package/node_modules/@groove-dev/gui/src/stores/slices/axom-slice.js ADDED Viewed

@@ -0,0 +1,197 @@
+// FSL-1.1-Apache-2.0 — see LICENSE
+//
+// Axom provider state. Everything rendered from this slice is
+// telemetry-grounded: interrupt/stop UI states flip on EVENTS from the
+// runtime, never on our own optimism (contract §2/§7 — fail-deceptive is
+// worse than fail-open).
+import { api } from '../../lib/api';
+const EVENT_BUFFER = 2000;
+const sessionKey = (endpoint, session) => `${endpoint}/${session}`;
+export const createAxomSlice = (set, get) => ({
+  // ── Axom Provider ─────────────────────────────────────────
+  axomStatus: { endpoints: [] },
+  axomSelected: null, // { endpoint, session }
+  axomEvents: {}, // sessionKey -> [envelope] (bounded)
+  // Local interrupt ledger: id -> {text, state}. state: 'sent' (POST accepted,
+  // not yet seen on the stream) | 'heard' (interrupt event arrived) |
+  // 'acked' (interrupt_ack arrived). Rollup states come from pipeline_done.
+  axomInterrupts: {}, // sessionKey -> { [id]: {text, state, truncated} }
+  // Stop states: null | 'pending' (POST sent, nothing effected yet) |
+  // 'effected' (stop_effected seen) | 'resolved-before-stop' (§7 edge:
+  // pipeline_done arrived with no stop_effected).
+  axomStops: {}, // sessionKey -> state
+  // Contract-violation log (§8): e.g. an interrupt_ack without interrupt_id.
+  // A fallback that fires must announce itself — never degrade silently.
+  axomAnomalies: {}, // sessionKey -> [{eventId, message}]
+  axomInstances: [], // managed local instances (contract §11)
+  axomInstall: { phase: 'idle', file: null, receivedBytes: 0, totalBytes: 0, error: null },
+  axomHardware: null, // machine readiness report for local inference
+  axomMyEndpoint: null, // this GROOVE's own Axom endpoint (share/copy)
+  async fetchAxomStatus() {
+    try {
+      const data = await api.get('/axom/status');
+      set({ axomStatus: data || { endpoints: [] } });
+      const instances = await api.get('/axom/instances');
+      set({ axomInstances: instances || [] });
+    } catch { /* daemon predates the axom routes */ }
+  },
+  async fetchAxomHardware() {
+    try {
+      const data = await api.get('/axom/hardware');
+      set({ axomHardware: data });
+    } catch { /* daemon predates the route */ }
+    try {
+      const me = await api.get('/axom/my-endpoint');
+      set({ axomMyEndpoint: me });
+    } catch { /* daemon predates the route */ }
+  },
+  async startAxomInstall(manifestUrl) {
+    await api.post('/axom/install', manifestUrl ? { manifestUrl } : {});
+  },
+  async startAxomInstance(id = 'default') {
+    const instance = await api.post('/axom/instances', { id });
+    await get().fetchAxomStatus();
+    return instance;
+  },
+  async stopAxomInstance(id) {
+    await api.delete(`/axom/instances/${encodeURIComponent(id)}`);
+    await get().fetchAxomStatus();
+  },
+  async saveAxomEndpoints(endpoints) {
+    const data = await api.patch('/axom/config', { endpoints });
+    await get().fetchAxomStatus();
+    return data;
+  },
+  async selectAxomSession(endpoint, session) {
+    set({ axomSelected: { endpoint, session } });
+    // Backfill from the daemon's ring so a freshly opened tab has history.
+    try {
+      const data = await api.get(`/axom/sessions/${encodeURIComponent(session)}/events?endpoint=${encodeURIComponent(endpoint)}`);
+      const key = sessionKey(endpoint, session);
+      set((s) => {
+        const existing = s.axomEvents[key] || [];
+        const seen = new Set(existing.map((e) => e.id));
+        const merged = [...(data.events || []).filter((e) => !seen.has(e.id)), ...existing]
+          .sort((a, b) => (a.id < b.id ? -1 : 1))
+          .slice(-EVENT_BUFFER);
+        return { axomEvents: { ...s.axomEvents, [key]: merged } };
+      });
+    } catch { /* session may have no ring yet — live events still flow */ }
+  },
+  ingestAxomEvent(endpoint, session, envelope) {
+    const key = sessionKey(endpoint, session);
+    set((s) => {
+      const buf = s.axomEvents[key] || [];
+      if (buf.length && buf[buf.length - 1].id === envelope.id) return {}; // WS echo guard
+      const updates = {
+        axomEvents: { ...s.axomEvents, [key]: [...buf, envelope].slice(-EVENT_BUFFER) },
+      };
+      // Interrupt lifecycle — driven only by what the runtime says happened.
+      // §8 pins interrupt_ack.payload.interrupt_id as ALWAYS present; the
+      // oldest-pending fallback stays as defense but surfaces as an anomaly
+      // when it fires — an ack without an id is a runtime bug to expose.
+      if (envelope.kind === 'interrupt' || envelope.kind === 'interrupt_ack') {
+        const ledger = { ...(s.axomInterrupts[key] || {}) };
+        const evId = envelope.payload?.interrupt_id ?? envelope.payload?.id;
+        const nextState = envelope.kind === 'interrupt' ? 'heard' : 'acked';
+        if (evId && ledger[evId]) {
+          ledger[evId] = { ...ledger[evId], state: nextState };
+        } else if (evId) {
+          // Known id, not ours — an interrupt posted by another client (e.g.
+          // typed straight into the REPL). Normal; it lives in the ticker,
+          // our ledger stays untouched.
+        } else {
+          // No id at all — a shape violation per §8. Advance the oldest
+          // pending entry as defense, and announce that the fallback fired.
+          const pending = Object.entries(ledger).find(([, v]) => v.state !== nextState && v.state !== 'acked');
+          if (pending) ledger[pending[0]] = { ...pending[1], state: nextState };
+          updates.axomAnomalies = {
+            ...s.axomAnomalies,
+            [key]: [
+              ...(s.axomAnomalies[key] || []),
+              { eventId: envelope.id, message: `${envelope.kind} arrived without an interrupt id (§8 violation)${pending ? ` — fallback advanced "${pending[1].text?.slice(0, 40)}"` : ''}` },
+            ].slice(-50),
+          };
+        }
+        updates.axomInterrupts = { ...s.axomInterrupts, [key]: ledger };
+      }
+      if (envelope.kind === 'stop_effected' && s.axomStops[key] === 'pending') {
+        updates.axomStops = { ...s.axomStops, [key]: 'effected' };
+      }
+      // §7 stop edge: the run can resolve before stop lands. Release the
+      // sticky pressed state on pipeline_done and say what actually happened.
+      if (envelope.kind === 'pipeline_done' && s.axomStops[key] === 'pending') {
+        updates.axomStops = { ...s.axomStops, [key]: 'resolved-before-stop' };
+      }
+      return updates;
+    });
+  },
+  // §12: message starts a turn on a caller-chosen session id (first message
+  // creates the session). 409 means a turn is in flight — steer instead.
+  async sendAxomMessage(text) {
+    const sel = get().axomSelected;
+    if (!sel) throw new Error('No Axom session selected');
+    try {
+      await api.post(`/axom/sessions/${encodeURIComponent(sel.session)}/message`, {
+        endpoint: sel.endpoint, text,
+      });
+      await get().fetchAxomStatus();
+      return { ok: true };
+    } catch (err) {
+      if (err.status === 409) return { busy: true };
+      if (err.status === 413) return { tooLong: true, max: err.body?.max };
+      throw err;
+    }
+  },
+  async sendAxomInterrupt(text) {
+    const sel = get().axomSelected;
+    if (!sel) throw new Error('No Axom session selected');
+    const result = await api.post(`/axom/sessions/${encodeURIComponent(sel.session)}/interrupt`, {
+      endpoint: sel.endpoint, text,
+    });
+    const key = sessionKey(sel.endpoint, sel.session);
+    set((s) => ({
+      axomInterrupts: {
+        ...s.axomInterrupts,
+        [key]: {
+          ...(s.axomInterrupts[key] || {}),
+          [result.id]: { text, state: 'sent', truncated: !!result.truncated },
+        },
+      },
+    }));
+    return result;
+  },
+  async sendAxomStop() {
+    const sel = get().axomSelected;
+    if (!sel) throw new Error('No Axom session selected');
+    const key = sessionKey(sel.endpoint, sel.session);
+    set((s) => ({ axomStops: { ...s.axomStops, [key]: 'pending' } }));
+    try {
+      return await api.post(`/axom/sessions/${encodeURIComponent(sel.session)}/stop`, { endpoint: sel.endpoint });
+    } catch (err) {
+      // The POST failed — nothing was requested, so the button must not stay
+      // pressed pretending it was.
+      set((s) => ({ axomStops: { ...s.axomStops, [key]: null } }));
+      throw err;
+    }
+  },
+});
+export { sessionKey as axomSessionKey };