@rubixkube/rubix 0.0.2 → 0.0.4

package/dist/core/rubix-api.js

@@ -1,4 +1,6 @@
 import { getConfig } from "../config/env.js";
+import { refreshAccessToken } from "./device-auth.js";
+import { saveAuthConfig } from "./auth-store.js";
 const DEFAULT_APP_NAME = "SRI Agent";
 export class StreamError extends Error {
     reason;
@@ -19,9 +21,38 @@ function opelBase() {
     }
     return value.replace(/\/+$/, "");
 }
+function memoryBase() {
+    const value = getConfig().memoryApiBase;
+    if (!value) {
+        throw new Error("RUBIXKUBE_MEMORY_API_BASE is not set.");
+    }
+    return value.replace(/\/+$/, "");
+}
+export async function fetchSystemStats(auth) {
+    try {
+        const url = `${memoryBase()}/api/v1/observability/stats`;
+        const response = await fetchWithAutoRefresh(auth, url, {
+            method: "GET",
+            headers: headers(auth, true),
+        });
+        if (!response.ok)
+            return null;
+        const payload = (await response.json());
+        return {
+            insights: Number(payload.insights ?? 0),
+            activeInsights: Number(payload.activeInsights ?? 0),
+            resolvedInsights: Number(payload.resolvedInsights ?? 0),
+            rcaReports: Number(payload.rcaReports ?? 0),
+            lastUpdated: String(payload.lastUpdated ?? new Date().toISOString()),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 function ensureAuth(auth) {
     const token = auth.idToken ?? auth.authToken;
-    const userId = auth.userId ?? auth.userEmail;
+    const userId = auth.userEmail ?? auth.userId;
     if (!token) {
         throw new Error("Missing auth token. Run /login.");
     }
@@ -48,6 +79,38 @@ function headers(auth, includeTenant = true) {
     }
     return out;
 }
+export async function refreshAndUpdateAuth(auth) {
+    try {
+        const refreshed = await refreshAccessToken(auth);
+        await saveAuthConfig(refreshed);
+        return refreshed;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        throw new StreamError(`Token refresh failed: ${msg}. Please run /login again.`, {
+            reason: "http_error",
+            status: 401,
+        });
+    }
+}
+async function fetchWithAutoRefresh(auth, url, options) {
+    let response = await fetch(url, options);
+    if (response.status === 401) {
+        try {
+            auth = await refreshAndUpdateAuth(auth);
+            const newHeaders = { ...options.headers };
+            const token = auth.idToken ?? auth.authToken;
+            if (token) {
+                newHeaders.Authorization = `Bearer ${token}`;
+            }
+            response = await fetch(url, { ...options, headers: newHeaders });
+        }
+        catch {
+            return response;
+        }
+    }
+    return response;
+}
 async function parseJsonResponse(response) {
     if (!response.ok) {
         const text = await response.text();
@@ -159,6 +222,19 @@ function parseToolNameFromText(value) {
         return callMatch[1];
     return "";
 }
+export async function listApps(auth) {
+    const url = `${opelBase()}/apps`;
+    const response = await fetchWithAutoRefresh(auth, url, {
+        method: "GET",
+        headers: headers(auth),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Failed to load agents (${response.status}): ${text}`);
+    }
+    const payload = await parseJsonResponse(response);
+    return payload.apps ?? [DEFAULT_APP_NAME];
+}
 function normalizeWorkflowEvent(type, content, details) {
     return {
         id: `${type}-${Date.now()}-${Math.random().toString(16).slice(2)}`,
@@ -171,7 +247,7 @@ function normalizeWorkflowEvent(type, content, details) {
 export async function listSessions(auth, limit = 20, offset = 0) {
     const { userId } = ensureAuth(auth);
     const url = `${opelBase()}/sessions/?user_id=${encodeURIComponent(userId)}&limit=${limit}&offset=${offset}`;
-    const response = await fetch(url, {
+    const response = await fetchWithAutoRefresh(auth, url, {
         method: "GET",
         headers: headers(auth),
     });
@@ -190,7 +266,7 @@ export async function listSessions(auth, limit = 20, offset = 0) {
     }))
         .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
 }
-export async function createSession(auth, appName = DEFAULT_APP_NAME, clusterId) {
+export async function createSession(auth, appName = DEFAULT_APP_NAME, clusterId, modelId) {
     const { userId, tenantId } = ensureAuth(auth);
     if (!tenantId) {
         throw new Error("Missing tenant ID. Run /login.");
@@ -208,11 +284,12 @@ export async function createSession(auth, appName = DEFAULT_APP_NAME, clusterId)
             session_created_at: new Date().toISOString(),
             client_type: "rubix-cli",
             ...(clusterId ? { cluster_id: clusterId, default_namespace: "default" } : {}),
+            ...(modelId ? { model_id: modelId } : {}),
             ...(auth.userRole ? { user_role: auth.userRole } : {}),
             ...(auth.tenantPlan ? { tenant_plan: auth.tenantPlan } : {}),
         },
     };
-    const response = await fetch(`${opelBase()}/sessions/`, {
+    const response = await fetchWithAutoRefresh(auth, `${opelBase()}/sessions/`, {
         method: "POST",
         headers: headers(auth),
         body: JSON.stringify(payload),
@@ -223,9 +300,9 @@ export async function createSession(auth, appName = DEFAULT_APP_NAME, clusterId)
     }
     return parsed.id;
 }
-export async function updateSessionState(auth, sessionId, state) {
-    const url = `${opelBase()}/sessions/${encodeURIComponent(sessionId)}?app_name=${encodeURIComponent(DEFAULT_APP_NAME)}`;
-    const response = await fetch(url, {
+export async function updateSessionState(auth, sessionId, state, appName = DEFAULT_APP_NAME) {
+    const url = `${opelBase()}/sessions/${encodeURIComponent(sessionId)}?app_name=${encodeURIComponent(appName)}`;
+    const response = await fetchWithAutoRefresh(auth, url, {
         method: "PUT",
         headers: headers(auth),
         body: JSON.stringify({ state }),
@@ -235,20 +312,46 @@ export async function updateSessionState(auth, sessionId, state) {
         throw new Error(`Failed to update session (${response.status}): ${text}`);
     }
 }
-export async function getOrCreateSession(auth, preferredId, clusterId) {
+export async function hasSessionMessages(auth, sessionId) {
+    try {
+        const { userId } = ensureAuth(auth);
+        // Fetch just 1 history event — cheapest possible check.
+        const url = `${opelBase()}/sessions/${encodeURIComponent(sessionId)}/chat-history?user_id=${encodeURIComponent(userId)}&limit=1&offset=0&format=detailed&order_desc=false`;
+        const response = await fetchWithAutoRefresh(auth, url, {
+            method: "GET",
+            headers: headers(auth),
+        });
+        if (!response.ok)
+            return false;
+        const payload = (await response.json());
+        return (payload.chat_history?.length ?? 0) > 0;
+    }
+    catch {
+        // If we can't determine, assume no messages so we reuse rather than spam new sessions.
+        return false;
+    }
+}
+export async function getOrCreateSession(auth, preferredId, clusterId, appName = DEFAULT_APP_NAME) {
     if (preferredId)
         return preferredId;
     const sessions = await listSessions(auth, 50, 0);
     if (sessions.length > 0) {
-        const recent = sessions[0];
+        // Attempt to find the most recent empty session for the same app
+        // Note: since list_sessions merges across apps now, we iterate
+        // until we find one that matches our appName.
+        const recent = sessions.find(s => s.appName === appName) ?? sessions[0];
         // Reuse the session only if it has matching cluster context (or no cluster was requested)
-        if (!clusterId || recent.clusterId === clusterId)
-            return recent.id;
+        // AND it has no messages — otherwise start fresh.
+        if (!clusterId || recent.clusterId === clusterId) {
+            const isEmpty = !(await hasSessionMessages(auth, recent.id));
+            if (isEmpty)
+                return recent.id;
+        }
     }
-    return createSession(auth, undefined, clusterId);
+    return createSession(auth, appName, clusterId);
 }
 const HEALTHY_STATUSES = new Set(["connected", "healthy", "active"]);
-export async function listClusters(auth) {
+export async function listEnvironments(auth) {
     const authBase = getConfig().authApiBase;
     if (!authBase)
         throw new Error("RUBIXKUBE_AUTH_API_BASE is not set.");
@@ -257,7 +360,7 @@ export async function listClusters(auth) {
         throw new Error("Missing tenant ID. Run /login.");
     }
     const url = `${authBase.replace(/\/+$/, "")}/clusters/?page=1&page_size=50`;
-    const response = await fetch(url, {
+    const response = await fetchWithAutoRefresh(auth, url, {
         method: "GET",
         headers: {
             Authorization: `Bearer ${token}`,
@@ -267,22 +370,91 @@ export async function listClusters(auth) {
     });
     if (!response.ok) {
         const text = await response.text();
-        throw new Error(`Failed to load clusters (${response.status}): ${text}`);
+        throw new Error(`Failed to load environments (${response.status}): ${text}`);
     }
     const payload = (await response.json());
     return (payload.clusters ?? [])
         .filter((c) => !!c?.cluster_id)
         .map((c) => ({
         id: c.id ?? c.cluster_id ?? "",
-        cluster_id: c.cluster_id ?? "",
-        name: c.name ?? c.cluster_id ?? "Unnamed cluster",
+        environment_id: c.cluster_id ?? "",
+        name: c.name ?? c.cluster_id ?? "Unnamed environment",
         status: (c.status ?? "unknown"),
         region: c.region,
-        cluster_type: c.cluster_type,
+        environment_type: c.cluster_type,
     }));
 }
-export function firstHealthyCluster(clusters) {
-    return clusters.find((c) => HEALTHY_STATUSES.has(c.status)) ?? clusters[0] ?? null;
+export function firstHealthyEnvironment(environments) {
+    return environments.find((c) => HEALTHY_STATUSES.has(c.status)) ?? environments[0] ?? null;
+}
+export async function listModels(auth) {
+    const url = `${opelBase()}/models`;
+    const response = await fetchWithAutoRefresh(auth, url, {
+        method: "GET",
+        headers: headers(auth, false),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new StreamError(`Failed to load models (${response.status}): ${text}`, {
+            status: response.status,
+            reason: "http_error",
+        });
+    }
+    const payload = await parseJsonResponse(response);
+    return (payload.models ?? [])
+        .filter((m) => !!m?.id)
+        .map((m) => ({
+        id: m.id ?? "",
+        model: m.model ?? "",
+        display_name: m.display_name ?? "",
+        description: m.description,
+        thinking_supported: m.thinking_supported ?? false,
+        agent: m.agent ?? "sre_agent",
+        default: m.default ?? false,
+        experimental: m.experimental,
+    }));
+}
+export async function setSessionModel(auth, sessionId, modelId, appName = DEFAULT_APP_NAME) {
+    const { userId } = ensureAuth(auth);
+    const url = `${opelBase()}/sessions/${encodeURIComponent(sessionId)}/model`;
+    const response = await fetchWithAutoRefresh(auth, url, {
+        method: "POST",
+        headers: headers(auth, true),
+        body: JSON.stringify({
+            user_id: userId,
+            model_id: modelId,
+            app_name: appName,
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        let errorMsg = `HTTP ${response.status}: ${text || response.statusText}`;
+        try {
+            const errorPayload = JSON.parse(text);
+            const error = errorPayload.detail?.error ?? "Unknown error";
+            const available = errorPayload.detail?.available ?? [];
+            if (available.length > 0) {
+                errorMsg = `${error}. Available: ${available.join(", ")}`;
+            }
+            else {
+                errorMsg = error;
+            }
+        }
+        catch {
+            // Fall back to generic error message
+        }
+        throw new StreamError(errorMsg, {
+            status: response.status,
+            reason: "http_error",
+        });
+    }
+    const parsed = await parseJsonResponse(response);
+    return {
+        modelId: parsed.model_id ?? modelId,
+        model: parsed.model ?? "",
+        displayName: parsed.display_name ?? "",
+        thinkingSupported: parsed.thinking_supported ?? false,
+    };
 }
 function parseParts(content) {
     if (!content)
@@ -301,7 +473,7 @@ function parseParts(content) {
 export async function fetchChatHistory(auth, sessionId, limit = 50) {
     const { userId } = ensureAuth(auth);
     const url = `${opelBase()}/sessions/${encodeURIComponent(sessionId)}/chat-history?user_id=${encodeURIComponent(userId)}&limit=${limit}&offset=0&format=detailed&order_desc=false`;
-    const response = await fetch(url, {
+    const response = await fetchWithAutoRefresh(auth, url, {
         method: "GET",
         headers: headers(auth),
     });
@@ -318,15 +490,25 @@ export async function fetchChatHistory(auth, sessionId, limit = 50) {
         let text = "";
         const workflow = [];
         for (const part of parts) {
-            if (part.thought === true)
+            if (part.thought === true) {
+                if (typeof part.text === "string" && part.text.trim()) {
+                    workflow.push({
+                        id: `hist-th-${idx}-${workflow.length}`,
+                        type: "thought",
+                        content: part.text.trim(),
+                        ts,
+                    });
+                }
                 continue;
+            }
             const fc = part.functionCall ?? part.function_call;
             if (fc) {
                 const name = typeof fc.name === "string" ? fc.name : "tool";
+                const argsStr = fc.args && Object.keys(fc.args).length > 0 ? JSON.stringify(fc.args) : "";
                 workflow.push({
                     id: `hist-fc-${idx}-${name}`,
                     type: "function_call",
-                    content: name,
+                    content: argsStr,
                     ts,
                     details: { name, id: fc.id },
                 });
@@ -338,7 +520,7 @@ export async function fetchChatHistory(auth, sessionId, limit = 50) {
                 workflow.push({
                     id: `hist-fr-${idx}-${name}`,
                     type: "function_response",
-                    content: typeof fr.response === "string" ? fr.response : `[${name}]`,
+                    content: typeof fr.response === "string" ? fr.response : (fr.response ? JSON.stringify(fr.response) : `[${name}]`),
                     ts,
                     details: { name, id: fr.id },
                 });
@@ -362,7 +544,7 @@ export async function fetchChatHistory(auth, sessionId, limit = 50) {
 }
 export async function streamChat(input, callbacks = {}) {
     const { userId } = ensureAuth(input.auth);
-    const response = await fetch(`${opelBase()}/chat/${encodeURIComponent(userId)}/session/${encodeURIComponent(input.sessionId)}`, {
+    const response = await fetchWithAutoRefresh(input.auth, `${opelBase()}/chat/${encodeURIComponent(userId)}/session/${encodeURIComponent(input.sessionId)}`, {
         method: "POST",
         headers: headers(input.auth, true),
         signal: input.signal,
@@ -376,6 +558,8 @@ export async function streamChat(input, callbacks = {}) {
             streaming: true,
             minify: true,
             maxTextLen: -1,
+            ...(input.stateDelta ? { stateDelta: input.stateDelta } : {}),
+            ...(input.modelOverride ? { modelOverride: input.modelOverride } : {}),
         }),
     });
     if (!response.ok) {
@@ -453,8 +637,8 @@ export async function streamChat(input, callbacks = {}) {
                 hasWorkflowEvents = true;
                 const name = asText(functionCall.name) || "tool";
                 const args = functionCall.args ?? {};
-                const prettyArgs = Object.keys(args).length > 0 ? `: ${JSON.stringify(args)}` : "";
-                callbacks.onWorkflow?.(normalizeWorkflowEvent("function_call", `${name}${prettyArgs}`, {
+                const argsStr = Object.keys(args).length > 0 ? JSON.stringify(args) : "";
+                callbacks.onWorkflow?.(normalizeWorkflowEvent("function_call", argsStr, {
                     name,
                     id: functionCall.id,
                 }));

package/dist/core/session-store.js

@@ -0,0 +1,36 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const CONFIG_DIR = ".rubix";
+const SESSION_FILE = "sessions.json";
+export function getSessionPath() {
+    return path.join(os.homedir(), CONFIG_DIR, SESSION_FILE);
+}
+export async function loadLocalSessions() {
+    try {
+        const data = await fs.readFile(getSessionPath(), "utf8");
+        return JSON.parse(data);
+    }
+    catch (error) {
+        const asNodeError = error;
+        if (asNodeError.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+}
+export async function saveLocalSessions(sessions) {
+    await fs.mkdir(path.join(os.homedir(), CONFIG_DIR), { recursive: true, mode: 0o700 });
+    await fs.writeFile(getSessionPath(), JSON.stringify(sessions, null, 2), { mode: 0o600 });
+}
+export async function clearLocalSessions() {
+    try {
+        await fs.unlink(getSessionPath());
+    }
+    catch (error) {
+        const asNodeError = error;
+        if (asNodeError.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}

package/dist/core/settings.js

@@ -0,0 +1,30 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const CONFIG_DIR = ".rubix";
+const SETTINGS_FILE = "settings.json";
+export function getSettingsPath() {
+    return path.join(os.homedir(), CONFIG_DIR, SETTINGS_FILE);
+}
+export async function loadSettings() {
+    try {
+        const data = await fs.readFile(getSettingsPath(), "utf8");
+        const raw = JSON.parse(data);
+        if (raw.clusterId && !raw.environmentId) {
+            raw.environmentId = raw.clusterId;
+            delete raw.clusterId;
+        }
+        return raw;
+    }
+    catch (error) {
+        const asNodeError = error;
+        if (asNodeError.code === "ENOENT") {
+            return {};
+        }
+        throw error;
+    }
+}
+export async function saveSettings(settings) {
+    await fs.mkdir(path.join(os.homedir(), CONFIG_DIR), { recursive: true, mode: 0o700 });
+    await fs.writeFile(getSettingsPath(), JSON.stringify(settings, null, 2), { mode: 0o600 });
+}

package/dist/core/update-check.js

@@ -0,0 +1,51 @@
+/**
+ * Simple semver-ish comparison. Returns true if latest is strictly greater than current.
+ * Handles major.minor.patch format.
+ */
+function isNewer(latest, current) {
+    const l = latest.split(".").map(Number);
+    const c = current.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+        const lv = l[i] ?? 0;
+        const cv = c[i] ?? 0;
+        if (lv > cv)
+            return true;
+        if (lv < cv)
+            return false;
+    }
+    return false;
+}
+/**
+ * Check if a new version of the CLI is available on npm.
+ *
+ * To maintain performance, this should only be called once every 24 hours.
+ * Returns the latest version string if a new version is available, otherwise null.
+ */
+export async function checkForUpdate(currentVersion, lastCheckTime) {
+    const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+    const now = Date.now();
+    // Only check once every 24 hours
+    if (lastCheckTime && now - lastCheckTime < ONE_DAY_MS) {
+        return null;
+    }
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3000); // 3s timeout
+        const response = await fetch("https://registry.npmjs.org/@rubixkube/rubix/latest", {
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        const latestVersion = data.version;
+        if (latestVersion && isNewer(latestVersion, currentVersion)) {
+            return latestVersion;
+        }
+        return null;
+    }
+    catch {
+        // Fail silently — never block startup or show errors for update checks.
+        return null;
+    }
+}

package/dist/core/whats-new.js

@@ -0,0 +1,56 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Default items shown when CHANGELOG.md cannot be read or parsed.
+ */
+const FALLBACK = [];
+/**
+ * Parse the `## [<version>]` section from CHANGELOG.md and return its bullet items.
+ *
+ * Looks for lines matching `- <text>` under the first matching version heading.
+ * Stops when it hits the next version heading (`## [`) or end-of-file.
+ *
+ * Returns an empty array on any error so the splash screen always renders.
+ */
+export function loadWhatsNew(version, maxItems = 4) {
+    try {
+        const changelogPath = join(__dirname, "..", "..", "CHANGELOG.md");
+        const raw = readFileSync(changelogPath, "utf-8");
+        return parseWhatsNew(raw, version).slice(0, maxItems);
+    }
+    catch {
+        return FALLBACK;
+    }
+}
+/**
+ * Pure parser extracted for testability.
+ */
+export function parseWhatsNew(markdown, version) {
+    const lines = markdown.split("\n");
+    // Find the heading for the requested version: ## [0.0.3] or ## [0.0.3] - 2026-03-01
+    const versionHeading = `## [${version}]`;
+    let startIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].startsWith(versionHeading)) {
+            startIndex = i + 1;
+            break;
+        }
+    }
+    if (startIndex === -1)
+        return FALLBACK;
+    const items = [];
+    for (let i = startIndex; i < lines.length; i++) {
+        const line = lines[i];
+        // Stop at the next version heading
+        if (line.startsWith("## ["))
+            break;
+        // Collect bullet items (- text)
+        const match = line.match(/^[-*]\s+(.+)/);
+        if (match) {
+            items.push(match[1].trim());
+        }
+    }
+    return items;
+}