@rubixkube/rubix 0.0.2 → 0.0.3

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,25 @@
+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");
+        return JSON.parse(data);
+    }
+    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;
+}