@rubixkube/rubix 0.0.1

package/dist/core/rubix-api.js

@@ -0,0 +1,656 @@
+import { getConfig } from "../config/env.js";
+const DEFAULT_APP_NAME = "SRI Agent";
+export class StreamError extends Error {
+    reason;
+    status;
+    rawEvent;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "StreamError";
+        this.reason = options.reason ?? "stream_error";
+        this.status = options.status;
+        this.rawEvent = options.rawEvent;
+    }
+}
+function opelBase() {
+    const value = getConfig().opelApiBase;
+    if (!value) {
+        throw new Error("RUBIXKUBE_OPEL_API_BASE is not set.");
+    }
+    return value.replace(/\/+$/, "");
+}
+function ensureAuth(auth) {
+    const token = auth.idToken ?? auth.authToken;
+    const userId = auth.userId ?? auth.userEmail;
+    if (!token) {
+        throw new Error("Missing auth token. Run /login.");
+    }
+    if (!userId) {
+        throw new Error("Missing user profile (userId/email). Please login again.");
+    }
+    return {
+        token,
+        userId,
+        tenantId: auth.tenantId,
+    };
+}
+function headers(auth, includeTenant = true) {
+    const { token, tenantId } = ensureAuth(auth);
+    const out = {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+    };
+    if (includeTenant) {
+        if (!tenantId) {
+            throw new Error("Missing tenant ID. Run /login.");
+        }
+        out["X-Tenant-ID"] = tenantId;
+    }
+    return out;
+}
+async function parseJsonResponse(response) {
+    if (!response.ok) {
+        const text = await response.text();
+        throw new StreamError(`HTTP ${response.status}: ${text || response.statusText}`, {
+            status: response.status,
+            reason: "http_error",
+        });
+    }
+    return (await response.json());
+}
+function mergeChunks(existing, add) {
+    if (!existing)
+        return add;
+    if (!add)
+        return existing;
+    if (add === existing)
+        return existing;
+    if (add.startsWith(existing))
+        return add;
+    if (existing.startsWith(add))
+        return existing;
+    if (add.includes(existing))
+        return add;
+    if (existing.includes(add))
+        return existing;
+    const maxK = Math.min(existing.length, add.length);
+    for (let k = maxK; k > 0; k -= 1) {
+        if (existing.endsWith(add.slice(0, k))) {
+            return existing + add.slice(k);
+        }
+    }
+    return existing + add;
+}
+function asText(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === null || value === undefined)
+        return "";
+    return JSON.stringify(value);
+}
+function extractFunctionResult(response) {
+    if (typeof response === "string")
+        return response;
+    if (!response || typeof response !== "object")
+        return asText(response);
+    const obj = response;
+    if (typeof obj.result === "string")
+        return obj.result;
+    if (typeof obj.output === "string")
+        return obj.output;
+    if (typeof obj.text === "string")
+        return obj.text;
+    if (Array.isArray(obj.result?.content)) {
+        const entries = obj.result.content;
+        return entries
+            .map((entry) => {
+            if (typeof entry === "string")
+                return entry;
+            if (entry && typeof entry === "object" && typeof entry.text === "string") {
+                return entry.text;
+            }
+            return "";
+        })
+            .filter((entry) => entry.trim().length > 0)
+            .join("\n");
+    }
+    if (Array.isArray(obj.content)) {
+        return obj.content
+            .map((entry) => {
+            if (typeof entry === "string")
+                return entry;
+            if (entry && typeof entry === "object" && typeof entry.text === "string") {
+                return entry.text;
+            }
+            return "";
+        })
+            .filter((entry) => entry.trim().length > 0)
+            .join("\n");
+    }
+    return JSON.stringify(obj);
+}
+function extractFromPayload(value) {
+    if (!value || typeof value !== "object")
+        return "";
+    const record = value;
+    const fullText = asText(record.full_text ?? record.fullText).trim();
+    if (fullText)
+        return fullText;
+    const message = asText(record.message).trim();
+    if (message)
+        return message;
+    const text = asText(record.text).trim();
+    if (text)
+        return text;
+    return "";
+}
+function parseToolNameFromText(value) {
+    const text = (value ?? "").trim();
+    if (!text)
+        return "";
+    const parenMatch = text.match(/^([a-zA-Z0-9_.:-]+)\s*\(/);
+    if (parenMatch?.[1])
+        return parenMatch[1];
+    const bracketMatch = text.match(/\[([a-zA-Z0-9_.:-]+)\]/);
+    if (bracketMatch?.[1])
+        return bracketMatch[1];
+    const callMatch = text.match(/(?:tool|function)\s+([a-zA-Z0-9_.:-]+)/i);
+    if (callMatch?.[1])
+        return callMatch[1];
+    return "";
+}
+function normalizeWorkflowEvent(type, content, details) {
+    return {
+        id: `${type}-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+        type,
+        content,
+        ts: Date.now(),
+        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, {
+        method: "GET",
+        headers: headers(auth),
+    });
+    const payload = await parseJsonResponse(response);
+    return (payload.sessions ?? [])
+        .filter((session) => !!session?.id)
+        .map((session) => ({
+        id: session.id ?? "",
+        appName: session.app_name ?? DEFAULT_APP_NAME,
+        createdAt: session.create_time ?? new Date().toISOString(),
+        updatedAt: session.update_time ?? session.create_time ?? new Date().toISOString(),
+        title: session.state?.session_title ?? session.title,
+        description: session.state?.session_description,
+        category: session.state?.session_category,
+        clusterId: session.state?.cluster_id,
+    }))
+        .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+}
+export async function createSession(auth, appName = DEFAULT_APP_NAME, clusterId) {
+    const { userId, tenantId } = ensureAuth(auth);
+    if (!tenantId) {
+        throw new Error("Missing tenant ID. Run /login.");
+    }
+    const payload = {
+        user_id: userId,
+        tenant_id: tenantId,
+        app_name: appName,
+        state: {
+            tenant_id: tenantId,
+            user_id: userId,
+            user_name: auth.userName ?? "Operator",
+            user_email: auth.userEmail ?? userId,
+            app_name: appName,
+            session_created_at: new Date().toISOString(),
+            client_type: "rubix-cli",
+            ...(clusterId ? { cluster_id: clusterId, default_namespace: "default" } : {}),
+            ...(auth.userRole ? { user_role: auth.userRole } : {}),
+            ...(auth.tenantPlan ? { tenant_plan: auth.tenantPlan } : {}),
+        },
+    };
+    const response = await fetch(`${opelBase()}/sessions/`, {
+        method: "POST",
+        headers: headers(auth),
+        body: JSON.stringify(payload),
+    });
+    const parsed = await parseJsonResponse(response);
+    if (!parsed.id) {
+        throw new Error("Session created without id.");
+    }
+    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, {
+        method: "PUT",
+        headers: headers(auth),
+        body: JSON.stringify({ state }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Failed to update session (${response.status}): ${text}`);
+    }
+}
+export async function getOrCreateSession(auth, preferredId, clusterId) {
+    if (preferredId)
+        return preferredId;
+    const sessions = await listSessions(auth, 50, 0);
+    if (sessions.length > 0) {
+        const recent = 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;
+    }
+    return createSession(auth, undefined, clusterId);
+}
+const HEALTHY_STATUSES = new Set(["connected", "healthy", "active"]);
+export async function listClusters(auth) {
+    const authBase = getConfig().authApiBase;
+    if (!authBase)
+        throw new Error("RUBIXKUBE_AUTH_API_BASE is not set.");
+    const { token, tenantId } = ensureAuth(auth);
+    if (!tenantId) {
+        throw new Error("Missing tenant ID. Run /login.");
+    }
+    const url = `${authBase.replace(/\/+$/, "")}/clusters/?page=1&page_size=50`;
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+            "X-Tenant-ID": tenantId,
+        },
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Failed to load clusters (${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",
+        status: (c.status ?? "unknown"),
+        region: c.region,
+        cluster_type: c.cluster_type,
+    }));
+}
+export function firstHealthyCluster(clusters) {
+    return clusters.find((c) => HEALTHY_STATUSES.has(c.status)) ?? clusters[0] ?? null;
+}
+function parseParts(content) {
+    if (!content)
+        return [];
+    if (typeof content === "string") {
+        try {
+            const parsed = JSON.parse(content);
+            return parsed.parts ?? [];
+        }
+        catch {
+            return [];
+        }
+    }
+    return content.parts ?? [];
+}
+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, {
+        method: "GET",
+        headers: headers(auth),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Failed to load chat history (${response.status}): ${text}`);
+    }
+    const payload = (await response.json());
+    const messages = [];
+    for (const [idx, msg] of (payload.chat_history ?? []).entries()) {
+        const role = msg.author === "user" ? "user" : "assistant";
+        const parts = parseParts(msg.content);
+        const ts = msg.timestamp ? new Date(msg.timestamp).getTime() : Date.now();
+        let text = "";
+        const workflow = [];
+        for (const part of parts) {
+            if (part.thought === true)
+                continue;
+            const fc = part.functionCall ?? part.function_call;
+            if (fc) {
+                const name = typeof fc.name === "string" ? fc.name : "tool";
+                workflow.push({
+                    id: `hist-fc-${idx}-${name}`,
+                    type: "function_call",
+                    content: name,
+                    ts,
+                    details: { name, id: fc.id },
+                });
+                continue;
+            }
+            const fr = part.functionResponse ?? part.function_response;
+            if (fr) {
+                const name = typeof fr.name === "string" ? fr.name : "tool";
+                workflow.push({
+                    id: `hist-fr-${idx}-${name}`,
+                    type: "function_response",
+                    content: typeof fr.response === "string" ? fr.response : `[${name}]`,
+                    ts,
+                    details: { name, id: fr.id },
+                });
+                continue;
+            }
+            if (typeof part.text === "string" && part.text.trim()) {
+                text = text ? `${text}\n${part.text}` : part.text;
+            }
+        }
+        if (!text.trim() && workflow.length === 0)
+            continue;
+        messages.push({
+            id: msg.invocation_id ? `${msg.invocation_id}-${idx}` : `hist-${idx}`,
+            role,
+            content: text,
+            ts,
+            workflow: workflow.length > 0 ? workflow : undefined,
+        });
+    }
+    return messages;
+}
+export async function streamChat(input, callbacks = {}) {
+    const { userId } = ensureAuth(input.auth);
+    const response = await fetch(`${opelBase()}/chat/${encodeURIComponent(userId)}/session/${encodeURIComponent(input.sessionId)}`, {
+        method: "POST",
+        headers: headers(input.auth, true),
+        signal: input.signal,
+        body: JSON.stringify({
+            userId,
+            sessionId: input.sessionId,
+            newMessage: {
+                role: "user",
+                parts: (input.messageParts ?? [{ text: input.message }]).map((p) => ({ text: p.text })),
+            },
+            streaming: true,
+            minify: true,
+            maxTextLen: -1,
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new StreamError(`HTTP ${response.status}: ${text || response.statusText}`, {
+            status: response.status,
+            reason: "http_error",
+        });
+    }
+    if (!response.body) {
+        throw new StreamError("No stream body returned by backend.", { reason: "stream_error" });
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let eventDataLines = [];
+    let accumulatedText = "";
+    let hasContent = false;
+    let hasWorkflowEvents = false;
+    let chunkCount = 0;
+    const handleEvent = (event) => {
+        const normalizedEventType = String(event.event_type ?? event.type ?? "").toLowerCase();
+        if (normalizedEventType === "stream_complete") {
+            return true;
+        }
+        if (normalizedEventType === "stream_error") {
+            throw new StreamError(event.error || event.message || "Stream error", {
+                reason: "stream_error",
+                rawEvent: event,
+            });
+        }
+        if (normalizedEventType === "stream_terminated") {
+            if (hasContent || hasWorkflowEvents)
+                return true;
+            throw new StreamError("Stream terminated without content.", {
+                reason: "stream_error",
+                rawEvent: event,
+            });
+        }
+        const stateDelta = event.actions && !Array.isArray(event.actions) && typeof event.actions === "object"
+            ? event.actions.stateDelta
+            : undefined;
+        if (stateDelta) {
+            const metadata = {};
+            if (stateDelta.session_title)
+                metadata.title = stateDelta.session_title;
+            if (stateDelta.session_description)
+                metadata.description = stateDelta.session_description;
+            if (stateDelta.session_category)
+                metadata.category = stateDelta.session_category;
+            if (Array.isArray(stateDelta.suggestions)) {
+                metadata.suggestions = stateDelta.suggestions
+                    .filter((entry) => typeof entry === "string")
+                    .map((entry) => String(entry).trim())
+                    .filter((entry) => entry.length > 0);
+            }
+            if (Object.keys(metadata).length > 0) {
+                callbacks.onSessionMetadata?.(metadata);
+            }
+        }
+        const parts = event.content?.parts ?? [];
+        const isThoughtType = normalizedEventType === "thought" || normalizedEventType === "thoughts";
+        for (const part of parts) {
+            const partText = typeof part.text === "string" ? part.text : "";
+            if ((part.thought === true || isThoughtType) && partText.trim()) {
+                hasWorkflowEvents = true;
+                callbacks.onWorkflow?.(normalizeWorkflowEvent("thought", partText.trim(), {
+                    partial: event.partial === true,
+                }));
+                continue;
+            }
+            const functionCall = part.functionCall ??
+                part.function_call;
+            if (functionCall) {
+                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}`, {
+                    name,
+                    id: functionCall.id,
+                }));
+                continue;
+            }
+            const functionResponse = part.functionResponse ??
+                part.function_response;
+            if (functionResponse) {
+                hasWorkflowEvents = true;
+                const name = asText(functionResponse.name) || "tool";
+                const result = extractFunctionResult(functionResponse.response);
+                callbacks.onWorkflow?.(normalizeWorkflowEvent("function_response", result || `[${name}]`, {
+                    name,
+                    id: functionResponse.id,
+                }));
+                continue;
+            }
+            if (partText && part.thought !== true) {
+                const merged = mergeChunks(accumulatedText, partText);
+                if (merged !== accumulatedText) {
+                    accumulatedText = merged;
+                    hasContent = accumulatedText.trim().length > 0;
+                    callbacks.onText?.(accumulatedText);
+                }
+            }
+        }
+        if (parts.length === 0) {
+            if (isThoughtType) {
+                const thoughtText = asText(event.message || event.text).trim() ||
+                    extractFromPayload(event.payload) ||
+                    extractFromPayload(event.data);
+                if (thoughtText) {
+                    hasWorkflowEvents = true;
+                    callbacks.onWorkflow?.(normalizeWorkflowEvent("thought", thoughtText, {
+                        partial: event.partial === true,
+                    }));
+                }
+            }
+            if (normalizedEventType === "function_call") {
+                const functionCall = event.functionCall ??
+                    event.function_call ??
+                    event.payload?.functionCall ??
+                    event.payload?.function_call ??
+                    event.data?.functionCall ??
+                    event.data?.function_call;
+                const fallbackText = asText(event.message || event.text).trim() ||
+                    extractFromPayload(event.payload) ||
+                    extractFromPayload(event.data);
+                const name = asText(functionCall?.name).trim() ||
+                    asText(event.name).trim() ||
+                    parseToolNameFromText(fallbackText) ||
+                    "tool";
+                const args = functionCall?.args ?? {};
+                const prettyArgs = Object.keys(args).length > 0 ? `: ${JSON.stringify(args)}` : "";
+                const content = prettyArgs ? `${name}${prettyArgs}` : name;
+                hasWorkflowEvents = true;
+                callbacks.onWorkflow?.(normalizeWorkflowEvent("function_call", content, {
+                    name,
+                    id: functionCall?.id ?? event.id,
+                }));
+            }
+            if (normalizedEventType === "function_response") {
+                const functionResponse = event.functionResponse ??
+                    event.function_response ??
+                    event.payload?.functionResponse ??
+                    event.payload?.function_response ??
+                    event.data?.functionResponse ??
+                    event.data?.function_response;
+                const name = asText(functionResponse?.name).trim() ||
+                    asText(event.name).trim() ||
+                    parseToolNameFromText(asText(event.message || event.text)) ||
+                    "tool";
+                const result = extractFunctionResult(functionResponse?.response) ||
+                    asText(event.message || event.text).trim() ||
+                    extractFromPayload(event.payload) ||
+                    extractFromPayload(event.data) ||
+                    `[${name}]`;
+                hasWorkflowEvents = true;
+                callbacks.onWorkflow?.(normalizeWorkflowEvent("function_response", result, {
+                    name,
+                    id: functionResponse?.id ?? event.id,
+                }));
+            }
+        }
+        if (event.text && parts.length === 0) {
+            const merged = mergeChunks(accumulatedText, event.text);
+            if (merged !== accumulatedText) {
+                accumulatedText = merged;
+                hasContent = accumulatedText.trim().length > 0;
+                callbacks.onText?.(accumulatedText);
+            }
+        }
+        return false;
+    };
+    try {
+        const flushEvent = () => {
+            const payload = eventDataLines.join("\n").trim();
+            eventDataLines = [];
+            if (!payload || payload === "[DONE]")
+                return false;
+            let event;
+            try {
+                event = JSON.parse(payload);
+            }
+            catch {
+                return false;
+            }
+            chunkCount += 1;
+            return handleEvent(event);
+        };
+        const maybeDispatchSingleLine = () => {
+            if (eventDataLines.length !== 1)
+                return false;
+            const payload = eventDataLines[0]?.trim() ?? "";
+            if (!payload || payload === "[DONE]") {
+                eventDataLines = [];
+                return false;
+            }
+            let event;
+            try {
+                event = JSON.parse(payload);
+            }
+            catch {
+                return false;
+            }
+            // Handle non-standard streams that omit blank-line event delimiters.
+            eventDataLines = [];
+            chunkCount += 1;
+            return handleEvent(event);
+        };
+        const processLine = (rawLine) => {
+            const line = rawLine.replace(/\r$/, "");
+            if (!line.trim()) {
+                return flushEvent();
+            }
+            if (line.startsWith(":")) {
+                return false;
+            }
+            if (line.startsWith("event:") || line.startsWith("id:") || line.startsWith("retry:")) {
+                return false;
+            }
+            if (line.startsWith("data:")) {
+                eventDataLines.push(line.slice(5).trimStart());
+            }
+            else if (line.trimStart().startsWith("{") || line.trimStart().startsWith("[")) {
+                // Tolerate raw JSON lines from non-SSE-compliant streams.
+                eventDataLines.push(line.trimStart());
+            }
+            return maybeDispatchSingleLine();
+        };
+        while (true) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                const completed = processLine(line);
+                if (completed) {
+                    return { text: accumulatedText };
+                }
+            }
+        }
+        if (buffer.trim().length > 0) {
+            const completed = processLine(buffer);
+            if (completed) {
+                return { text: accumulatedText };
+            }
+        }
+        if (eventDataLines.length > 0) {
+            const completed = flushEvent();
+            if (completed) {
+                return { text: accumulatedText };
+            }
+        }
+        // Stream ended naturally — match console behavior: complete if we got any chunks
+        if (chunkCount === 0) {
+            throw new StreamError("Stream ended without any response from the agent.", { reason: "stream_error" });
+        }
+        return { text: accumulatedText };
+    }
+    catch (error) {
+        if (error instanceof StreamError) {
+            throw error;
+        }
+        const abortError = (error instanceof DOMException && error.name === "AbortError") ||
+            (error?.name === "AbortError");
+        if (abortError) {
+            throw new StreamError("Stream cancelled by user.", { reason: "user_cancelled" });
+        }
+        throw new StreamError(error instanceof Error ? error.message : String(error), {
+            reason: "network_error",
+        });
+    }
+    finally {
+        reader.releaseLock();
+    }
+}

package/dist/core/trust-store.js

@@ -0,0 +1,51 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+const CONFIG_DIR = ".rubix";
+const TRUST_FILE = "trusted-folders.json";
+function getTrustPath() {
+    return path.join(os.homedir(), CONFIG_DIR, TRUST_FILE);
+}
+async function ensureConfigDir() {
+    await fs.mkdir(path.join(os.homedir(), CONFIG_DIR), { recursive: true, mode: 0o700 });
+}
+export async function loadTrustConfig() {
+    try {
+        const data = await fs.readFile(getTrustPath(), "utf8");
+        return JSON.parse(data);
+    }
+    catch (error) {
+        const asNodeError = error;
+        if (asNodeError.code === "ENOENT") {
+            return { folders: [], timestamp: Date.now() };
+        }
+        throw error;
+    }
+}
+export async function isFolderTrusted(folderPath) {
+    const config = await loadTrustConfig();
+    const resolved = path.resolve(folderPath);
+    return config.folders.includes(resolved);
+}
+export async function trustFolder(folderPath) {
+    await ensureConfigDir();
+    const config = await loadTrustConfig();
+    const resolved = path.resolve(folderPath);
+    if (!config.folders.includes(resolved)) {
+        config.folders.push(resolved);
+        config.timestamp = Date.now();
+        await fs.writeFile(getTrustPath(), JSON.stringify(config, null, 2), {
+            mode: 0o600,
+        });
+    }
+}
+export async function untrustFolder(folderPath) {
+    await ensureConfigDir();
+    const config = await loadTrustConfig();
+    const resolved = path.resolve(folderPath);
+    config.folders = config.folders.filter((f) => f !== resolved);
+    config.timestamp = Date.now();
+    await fs.writeFile(getTrustPath(), JSON.stringify(config, null, 2), {
+        mode: 0o600,
+    });
+}