@jxsuite/studio 0.31.1 → 0.33.0

package/src/recent-projects.ts

@@ -1,13 +1,12 @@
 /// <reference lib="dom" />
-interface RecentProject {
-  name: string;
-  root: string;
-  timestamp: number;
-}
+import { getPlatform, hasPlatform } from "./platform";
+import type { RecentProjectEntry } from "./types";
 
 interface RecentFile {
   path: string;
   name: string;
+  /** The project root the file belongs to, so recents can be scoped to the open project. */
+  root: string;
   timestamp: number;
 }
 
@@ -16,55 +15,154 @@ const FILES_STORAGE_KEY = "jx-studio-recent-files";
 const MAX_RECENT = 8;
 const MAX_RECENT_FILES = 10;
 
-/** @returns {RecentProject[]} */
-export function getRecentProjects() {
+/**
+ * In-memory mirror of the backend recent-projects store, hydrated once at startup. Render is
+ * synchronous, so reads come from here (or directly from localStorage on the dev server) rather
+ * than awaiting the backend.
+ */
+let cache: RecentProjectEntry[] = [];
+
+/**
+ * The active backend store, or null when none is available (dev server). Desktop and chromium
+ * persist a user-level file shared across all projects/windows; the dev server falls back to
+ * per-origin localStorage, which already survives reloads.
+ */
+function backend(): StudioRecentStore | null {
+  if (!hasPlatform()) {
+    return null;
+  }
+  const platform = getPlatform();
+  return platform.getRecentProjects && platform.saveRecentProjects
+    ? (platform as StudioRecentStore)
+    : null;
+}
+
+interface StudioRecentStore {
+  getRecentProjects: () => Promise<RecentProjectEntry[]>;
+  saveRecentProjects: (projects: RecentProjectEntry[]) => Promise<void>;
+}
+
+function loadFromLocalStorage(): RecentProjectEntry[] {
   try {
     const raw = localStorage.getItem(STORAGE_KEY);
     if (!raw) {
       return [];
     }
-    return (JSON.parse(raw) as RecentProject[]).toSorted((a, b) => b.timestamp - a.timestamp);
+    const parsed = JSON.parse(raw) as RecentProjectEntry[];
+    return Array.isArray(parsed) ? parsed : [];
   } catch {
     return [];
   }
 }
 
+/** The current list from whichever store is active (cache for backend, localStorage otherwise). */
+function currentList(): RecentProjectEntry[] {
+  return backend() ? cache : loadFromLocalStorage();
+}
+
+/** Persist a new list to the active store and keep the in-memory cache in sync. */
+function commit(list: RecentProjectEntry[]): void {
+  cache = list;
+  const store = backend();
+  if (store) {
+    void store.saveRecentProjects(list);
+  } else {
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(list));
+    } catch {
+      /* Storage unavailable — best effort */
+    }
+  }
+}
+
+/**
+ * Load the recent-projects list into the in-memory cache. Call once after the platform is
+ * registered; a no-op (other than priming the cache) on the dev server, where reads hit
+ * localStorage directly.
+ */
+export async function hydrateRecentProjects(): Promise<void> {
+  const store = backend();
+  if (!store) {
+    return;
+  }
+  try {
+    cache = await store.getRecentProjects();
+  } catch {
+    cache = [];
+  }
+}
+
+/** @returns {RecentProjectEntry[]} Newest-first */
+export function getRecentProjects(): RecentProjectEntry[] {
+  return currentList().toSorted((a, b) => b.timestamp - a.timestamp);
+}
+
 /**
  * @param {string} name
  * @param {string} root
  */
 export function addRecentProject(name: string, root: string) {
-  const projects = getRecentProjects().filter((p) => p.root !== root);
+  const projects = currentList().filter((p) => p.root !== root);
   projects.unshift({ name, root, timestamp: Date.now() });
   if (projects.length > MAX_RECENT) {
     projects.length = MAX_RECENT;
   }
-  localStorage.setItem(STORAGE_KEY, JSON.stringify(projects));
+  commit(projects);
+}
+
+/** Drop a single project from the recent list (used by the UI remove action + auto-prune). */
+export function removeRecentProject(root: string) {
+  commit(currentList().filter((p) => p.root !== root));
 }
 
 export function clearRecentProjects() {
-  localStorage.removeItem(STORAGE_KEY);
+  cache = [];
+  const store = backend();
+  if (store) {
+    void store.saveRecentProjects([]);
+  } else {
+    localStorage.removeItem(STORAGE_KEY);
+  }
 }
 
-/** @returns {RecentFile[]} */
-export function getRecentFiles() {
+function loadRecentFiles(): RecentFile[] {
   try {
     const raw = localStorage.getItem(FILES_STORAGE_KEY);
     if (!raw) {
       return [];
     }
-    return (JSON.parse(raw) as RecentFile[]).toSorted((a, b) => b.timestamp - a.timestamp);
+    const parsed = JSON.parse(raw) as RecentFile[];
+    return Array.isArray(parsed) ? parsed : [];
   } catch {
     return [];
   }
 }
 
-/** @param {{ path: string; name: string }} file */
-export function trackRecentFile(file: { path: string; name: string }) {
-  const recent = getRecentFiles().filter((f) => f.path !== file.path);
-  recent.unshift({ name: file.name, path: file.path, timestamp: Date.now() });
-  if (recent.length > MAX_RECENT_FILES) {
-    recent.length = MAX_RECENT_FILES;
+/**
+ * Recently-opened files, newest-first. Pass a project `root` to scope the list to that project (the
+ * Quick Access modal does this so it only ever shows files from the open project).
+ *
+ * @param {string} [root]
+ * @returns {RecentFile[]}
+ */
+export function getRecentFiles(root?: string) {
+  const all = loadRecentFiles().toSorted((a, b) => b.timestamp - a.timestamp);
+  return root == null ? all : all.filter((f) => f.root === root);
+}
+
+/** @param {{ path: string; name: string; root: string }} file */
+export function trackRecentFile(file: { path: string; name: string; root: string }) {
+  const all = loadRecentFiles().filter((f) => !(f.root === file.root && f.path === file.path));
+  all.unshift({ name: file.name, path: file.path, root: file.root, timestamp: Date.now() });
+  // Cap per project so a busy project can't evict another project's history.
+  const perRoot = new Map<string, number>();
+  const kept: RecentFile[] = [];
+  for (const f of all.toSorted((a, b) => b.timestamp - a.timestamp)) {
+    const n = (perRoot.get(f.root) ?? 0) + 1;
+    perRoot.set(f.root, n);
+    if (n <= MAX_RECENT_FILES) {
+      kept.push(f);
+    }
   }
-  localStorage.setItem(FILES_STORAGE_KEY, JSON.stringify(recent));
+  localStorage.setItem(FILES_STORAGE_KEY, JSON.stringify(kept));
 }

package/src/services/ai-settings.ts

@@ -0,0 +1,107 @@
+/// <reference lib="dom" />
+/**
+ * Ai-settings.js — local persistence for the AI assistant's provider settings.
+ *
+ * The Stack B proxy reads the OpenAI key from the `X-Api-Key` header (falling back to the server's
+ * `OPENAI_API_KEY` env var). Studio stores a user-supplied key in localStorage so the browser/dev
+ * build works without an env var. The key never leaves the machine except to the same-origin proxy.
+ *
+ * @license MIT
+ */
+
+const KEY_STORAGE = "jx.ai.openaiKey";
+const BASE_URL_STORAGE = "jx.ai.baseUrl";
+const MODEL_STORAGE = "jx.ai.model";
+const DEFAULT_MODEL = "gpt-4o";
+
+/** @returns {string} The stored OpenAI key, or "" if none/unavailable. */
+export function getOpenAiKey() {
+  try {
+    return globalThis.localStorage?.getItem(KEY_STORAGE) ?? "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Persist (or clear) the OpenAI key.
+ *
+ * @param {string} key - The key to store; an empty/blank value clears it.
+ */
+export function setOpenAiKey(key: string) {
+  try {
+    const trimmed = (key || "").trim();
+    if (trimmed) {
+      globalThis.localStorage?.setItem(KEY_STORAGE, trimmed);
+    } else {
+      globalThis.localStorage?.removeItem(KEY_STORAGE);
+    }
+  } catch {
+    /* LocalStorage unavailable — settings are not persisted. */
+  }
+}
+
+/** @returns {boolean} Whether a non-empty key is stored. */
+export function hasOpenAiKey() {
+  return getOpenAiKey().length > 0;
+}
+
+/**
+ * @returns {string} The OpenAI-compatible base URL override (e.g. a local LLM, OpenRouter, Azure),
+ *   or "" to use the proxy's default (`https://api.openai.com/v1` / server `OPENAI_BASE_URL`).
+ */
+export function getBaseUrl() {
+  try {
+    return globalThis.localStorage?.getItem(BASE_URL_STORAGE) ?? "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Persist (or clear) the base URL override.
+ *
+ * @param {string} url - The base URL; an empty/blank value clears the override.
+ */
+export function setBaseUrl(url: string) {
+  try {
+    const trimmed = (url || "").trim().replace(/\/+$/, "");
+    if (trimmed) {
+      globalThis.localStorage?.setItem(BASE_URL_STORAGE, trimmed);
+    } else {
+      globalThis.localStorage?.removeItem(BASE_URL_STORAGE);
+    }
+  } catch {
+    /* LocalStorage unavailable — settings are not persisted. */
+  }
+}
+
+// ─── Model selection ────────────────────────────────────────────────────────
+
+/** @returns {string} The stored model ID, or the default ("gpt-4o"). */
+export function getModel() {
+  try {
+    return globalThis.localStorage?.getItem(MODEL_STORAGE) || DEFAULT_MODEL;
+  } catch {
+    return DEFAULT_MODEL;
+  }
+}
+
+/**
+ * Persist the selected model ID.
+ *
+ * @param {string} modelId - The model ID to store; an empty/blank value clears it, reverting to
+ *   default.
+ */
+export function setModel(modelId: string) {
+  try {
+    const trimmed = (modelId || "").trim();
+    if (trimmed) {
+      globalThis.localStorage?.setItem(MODEL_STORAGE, trimmed);
+    } else {
+      globalThis.localStorage?.removeItem(MODEL_STORAGE);
+    }
+  } catch {
+    /* LocalStorage unavailable — settings are not persisted. */
+  }
+}