@lotics/cli 0.35.0 → 0.36.1

package/dist/config.test.js

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
-import { loadConfig, saveConfig, deleteConfig, getConfigPath } from "./config.js";
+import { loadConfig, saveConfig, deleteConfig, getConfigPath, loadGlobalConfig, resolveContext, resolveProfileByNameOrId, upsertProfile, removeProfile, setActiveOrg, setSelectedWorkspace, } from "./config.js";
 /**
  * Config resolution walks up from the current working directory: the first
  * ancestor with a `.lotics/config.json` wins, otherwise the global
@@ -50,63 +50,270 @@ describe("config file resolution", () => {
         expect(loadConfig()).toBeNull();
     });
     it("reads the global config when no local config exists", () => {
-        write(globalFile(), { api_key: "ltk_global" });
-        expect(loadConfig()?.api_key).toBe("ltk_global");
+        write(globalFile(), { active_org: "org_global" });
+        expect(loadConfig()?.active_org).toBe("org_global");
         expect(getConfigPath()).toBe(globalFile());
     });
     it("prefers a .lotics/config.json in the current directory over the global one", () => {
-        write(globalFile(), { api_key: "ltk_global" });
-        write(localFile(), { api_key: "ltk_local" });
-        expect(loadConfig()?.api_key).toBe("ltk_local");
+        write(globalFile(), { active_org: "org_global" });
+        write(localFile(), { active_org: "org_local" });
+        expect(loadConfig()?.active_org).toBe("org_local");
         expect(getConfigPath()).toBe(localFile());
     });
     it("walks up to an ancestor's config when run from a subdirectory", () => {
-        write(localFile(), { api_key: "ltk_project_root" });
+        write(localFile(), { active_org: "org_project_root" });
         chdirInto("backend", "features");
-        expect(loadConfig()?.api_key).toBe("ltk_project_root");
+        expect(loadConfig()?.active_org).toBe("org_project_root");
         expect(getConfigPath()).toBe(localFile());
     });
     it("auto saveConfig writes the resolved ancestor file, not the subdirectory", () => {
-        write(localFile(), { api_key: "ltk_old" });
+        write(localFile(), { active_org: "org_old" });
         const nested = chdirInto("sub");
-        saveConfig({ api_key: "ltk_new" });
-        expect(read(localFile()).api_key).toBe("ltk_new");
+        saveConfig({ active_org: "org_new" });
+        expect(read(localFile()).active_org).toBe("org_new");
         expect(fs.existsSync(localFile(nested))).toBe(false);
     });
     it("auto saveConfig writes the global config when no local config exists", () => {
-        saveConfig({ api_key: "ltk_new" });
+        saveConfig({ active_org: "org_new" });
         expect(fs.existsSync(localFile())).toBe(false);
-        expect(read(globalFile()).api_key).toBe("ltk_new");
+        expect(read(globalFile()).active_org).toBe("org_new");
     });
     it("scope 'local' creates ./.lotics/config.json even when none existed", () => {
-        saveConfig({ api_key: "ltk_pinned" }, "local");
-        expect(read(localFile()).api_key).toBe("ltk_pinned");
+        saveConfig({ active_org: "org_pinned" }, "local");
+        expect(read(localFile()).active_org).toBe("org_pinned");
         expect(getConfigPath("local")).toBe(localFile());
     });
     it("saveConfig writes the credentials file owner-only (0600)", () => {
-        saveConfig({ api_key: "ltk_secret" }, "local");
+        saveConfig({ active_org: "org_secret" }, "local");
         expect(fs.statSync(localFile()).mode & 0o777).toBe(0o600);
     });
     it("saveConfig tightens an over-permissive pre-existing config file", () => {
-        write(localFile(), { api_key: "ltk_old" });
+        write(localFile(), { active_org: "org_old" });
         fs.chmodSync(localFile(), 0o644);
-        saveConfig({ api_key: "ltk_new" }, "local");
+        saveConfig({ active_org: "org_new" }, "local");
         expect(fs.statSync(localFile()).mode & 0o777).toBe(0o600);
     });
     it("loadConfig('local') never inherits the global config", () => {
-        write(globalFile(), { api_key: "ltk_global" });
+        write(globalFile(), { active_org: "org_global" });
         expect(loadConfig("local")).toBeNull();
     });
     it("loadConfig('local') ignores an ancestor's config — it reads the exact cwd only", () => {
-        write(localFile(), { api_key: "ltk_root" });
+        write(localFile(), { active_org: "org_root" });
         chdirInto("sub");
         expect(loadConfig("local")).toBeNull();
     });
     it("deleteConfig removes the active local config, leaving the global one untouched", () => {
-        write(globalFile(), { api_key: "ltk_global" });
-        write(localFile(), { api_key: "ltk_local" });
+        write(globalFile(), { active_org: "org_global" });
+        write(localFile(), { active_org: "org_local" });
         deleteConfig();
         expect(fs.existsSync(localFile())).toBe(false);
         expect(fs.existsSync(globalFile())).toBe(true);
     });
 });
+/**
+ * The credential store holds many profiles (one per org) in the global config,
+ * while a local pin or env var picks which is active. `resolveContext` is the
+ * single chain that turns flags + env + files into the effective
+ * (apiKey, workspaceId) — these tests pin home/cwd to temp dirs and scrub the
+ * LOTICS_* env vars so the real environment is never read.
+ */
+describe("profile store + resolveContext", () => {
+    let homeDir;
+    let projectDir;
+    let originalCwd;
+    const ENV_KEYS = ["LOTICS_API_KEY", "LOTICS_ORG", "LOTICS_WORKSPACE"];
+    let savedEnv;
+    beforeEach(() => {
+        originalCwd = process.cwd();
+        homeDir = fs.mkdtempSync(path.join(os.tmpdir(), "lotics-home-"));
+        projectDir = fs.mkdtempSync(path.join(os.tmpdir(), "lotics-project-"));
+        vi.spyOn(os, "homedir").mockReturnValue(homeDir);
+        process.chdir(projectDir);
+        savedEnv = {};
+        for (const k of ENV_KEYS) {
+            savedEnv[k] = process.env[k];
+            delete process.env[k];
+        }
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        vi.restoreAllMocks();
+        for (const k of ENV_KEYS) {
+            if (savedEnv[k] === undefined)
+                delete process.env[k];
+            else
+                process.env[k] = savedEnv[k];
+        }
+        fs.rmSync(homeDir, { recursive: true, force: true });
+        fs.rmSync(projectDir, { recursive: true, force: true });
+    });
+    // Raw writers: accept any JSON shape so tests can simulate older on-disk
+    // formats (e.g. a pre-profiles inline key) the current type no longer models.
+    const globalConfigFile = () => path.join(homeDir, ".lotics", "config.json");
+    const writeGlobalRaw = (data) => {
+        fs.mkdirSync(path.dirname(globalConfigFile()), { recursive: true });
+        fs.writeFileSync(globalConfigFile(), JSON.stringify(data));
+    };
+    const writeLocalRaw = (data) => {
+        const file = path.join(projectDir, ".lotics", "config.json");
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify(data));
+    };
+    const readGlobalRaw = () => JSON.parse(fs.readFileSync(globalConfigFile(), "utf-8"));
+    const profile = (orgName, key, ws) => ({
+        api_key: key,
+        org_name: orgName,
+        ...(ws ? { workspace_id: ws } : {}),
+    });
+    // --- resolveProfileByNameOrId ---
+    it("resolves a profile by exact org id", () => {
+        const profiles = { org_a: profile("Acme", "ltk_a") };
+        expect(resolveProfileByNameOrId(profiles, "org_a")?.[0]).toBe("org_a");
+    });
+    it("resolves a profile by case-insensitive org name", () => {
+        const profiles = { org_a: profile("Acme", "ltk_a") };
+        expect(resolveProfileByNameOrId(profiles, "acme")?.[0]).toBe("org_a");
+    });
+    it("returns null when no profile matches", () => {
+        expect(resolveProfileByNameOrId({ org_a: profile("Acme", "ltk_a") }, "nope")).toBeNull();
+    });
+    it("throws when an org name is ambiguous", () => {
+        const profiles = { org_a: profile("Dup", "ltk_a"), org_b: profile("Dup", "ltk_b") };
+        expect(() => resolveProfileByNameOrId(profiles, "Dup")).toThrow(/multiple/i);
+    });
+    // --- precedence chain ---
+    it("uses the --api-key flag above everything", () => {
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a") }, active_org: "org_a" });
+        const ctx = resolveContext({ apiKey: "ltk_flag", workspace: "wsp_flag" });
+        expect(ctx).toMatchObject({ apiKey: "ltk_flag", workspaceId: "wsp_flag", source: "flag" });
+    });
+    it("uses LOTICS_API_KEY above LOTICS_ORG and the files", () => {
+        process.env.LOTICS_API_KEY = "ltk_env";
+        process.env.LOTICS_WORKSPACE = "wsp_env";
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a") }, active_org: "org_a" });
+        const ctx = resolveContext({});
+        expect(ctx).toMatchObject({ apiKey: "ltk_env", workspaceId: "wsp_env", source: "env_key" });
+    });
+    it("resolves LOTICS_ORG (by name) against the global store", () => {
+        process.env.LOTICS_ORG = "Acme";
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a", "wsp_a") }, active_org: "org_a" });
+        const ctx = resolveContext({});
+        expect(ctx).toMatchObject({ apiKey: "ltk_a", orgId: "org_a", workspaceId: "wsp_a", source: "env_org" });
+    });
+    it("throws when LOTICS_ORG names no saved credential", () => {
+        process.env.LOTICS_ORG = "ghost";
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a") }, active_org: "org_a" });
+        expect(() => resolveContext({})).toThrow(/LOTICS_ORG/);
+    });
+    it("rejects a local config in the obsolete self-contained format (inline key)", () => {
+        // Must fail loud rather than silently fall through to the global active org,
+        // which would run this directory against the wrong organization.
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a") }, active_org: "org_a" });
+        writeLocalRaw({ api_key: "ltk_local", workspace_id: "wsp_local" });
+        expect(() => resolveContext({})).toThrow(/self-contained format/i);
+    });
+    it("resolves a local pointer's key from the global store", () => {
+        writeGlobalRaw({ profiles: { org_b: profile("Beta", "ltk_b", "wsp_b_default") }, active_org: "org_a" });
+        writeLocalRaw({ active_org: "org_b", workspace_id: "wsp_b_pinned" });
+        const ctx = resolveContext({});
+        expect(ctx).toMatchObject({
+            apiKey: "ltk_b",
+            orgId: "org_b",
+            workspaceId: "wsp_b_pinned",
+            source: "local_pointer",
+        });
+    });
+    it("fails loud when a local pin names an org with no saved credential", () => {
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a") }, active_org: "org_a" });
+        writeLocalRaw({ active_org: "org_missing" });
+        expect(() => resolveContext({})).toThrow(/no saved credential/i);
+    });
+    it("falls back to the global active profile when no override exists", () => {
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a", "wsp_a") }, active_org: "org_a" });
+        const ctx = resolveContext({});
+        expect(ctx).toMatchObject({ apiKey: "ltk_a", orgId: "org_a", workspaceId: "wsp_a", source: "global_profile" });
+    });
+    it("fails loud when the global active_org has no matching profile", () => {
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a") }, active_org: "org_gone" });
+        expect(() => resolveContext({})).toThrow(/no saved credential/i);
+    });
+    it("returns null for an old flat global config (no profiles) — re-auth required", () => {
+        writeGlobalRaw({ api_key: "ltk_legacy", workspace_id: "wsp_legacy" });
+        expect(resolveContext({})).toBeNull();
+    });
+    it("returns null when no credentials exist anywhere", () => {
+        expect(resolveContext({})).toBeNull();
+    });
+    it("lets --workspace / LOTICS_WORKSPACE override the resolved workspace", () => {
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a", "wsp_default") }, active_org: "org_a" });
+        expect(resolveContext({ workspace: "wsp_override" })?.workspaceId).toBe("wsp_override");
+        process.env.LOTICS_WORKSPACE = "wsp_env";
+        expect(resolveContext({})?.workspaceId).toBe("wsp_env");
+    });
+    // --- mutators ---
+    it("upsertProfile adds a profile and preserves the active pointer + the rest", () => {
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a") }, active_org: "org_a", email: "me@x.io" });
+        upsertProfile("org_b", { api_key: "ltk_b", org_name: "Beta", workspace_id: "wsp_b" });
+        const g = loadGlobalConfig();
+        expect(Object.keys(g.profiles)).toEqual(["org_a", "org_b"]);
+        expect(g.active_org).toBe("org_a"); // unchanged — the command sets active, not upsert
+        expect(g.email).toBe("me@x.io");
+    });
+    it("upsertProfile self-heals an old flat-key file by dropping stray top-level fields", () => {
+        writeGlobalRaw({ api_key: "ltk_legacy", workspace_id: "wsp_legacy", email: "me@x.io" });
+        upsertProfile("org_a", { api_key: "ltk_a", org_name: "Acme" });
+        const raw = readGlobalRaw();
+        expect(raw.api_key).toBeUndefined();
+        expect(raw.workspace_id).toBeUndefined();
+        expect(raw.email).toBe("me@x.io");
+        expect(raw.profiles.org_a.api_key).toBe("ltk_a");
+    });
+    it("upsertProfile keeps the remembered workspace when none is supplied", () => {
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a", "wsp_a") }, active_org: "org_a" });
+        upsertProfile("org_a", { api_key: "ltk_a2", org_name: "Acme" });
+        expect(loadGlobalConfig().profiles.org_a.workspace_id).toBe("wsp_a");
+    });
+    it("removeProfile deletes a profile and moves the active pointer", () => {
+        writeGlobalRaw({
+            profiles: { org_a: profile("Acme", "ltk_a"), org_b: profile("Beta", "ltk_b") },
+            active_org: "org_a",
+        });
+        removeProfile("org_a");
+        const g = loadGlobalConfig();
+        expect(g.profiles.org_a).toBeUndefined();
+        expect(g.active_org).toBe("org_b");
+    });
+    it("setActiveOrg('global') changes only the global default", () => {
+        writeGlobalRaw({
+            profiles: { org_a: profile("Acme", "ltk_a"), org_b: profile("Beta", "ltk_b") },
+            active_org: "org_a",
+        });
+        setActiveOrg("org_b", "global");
+        expect(loadGlobalConfig().active_org).toBe("org_b");
+        expect(fs.existsSync(path.join(projectDir, ".lotics", "config.json"))).toBe(false);
+    });
+    it("setActiveOrg('local') writes a pointer into the current directory only", () => {
+        writeGlobalRaw({ profiles: { org_b: profile("Beta", "ltk_b") }, active_org: "org_a" });
+        setActiveOrg("org_b", "local");
+        expect(loadConfig("local").active_org).toBe("org_b");
+        expect(loadGlobalConfig().active_org).toBe("org_a"); // global untouched
+    });
+    it("setSelectedWorkspace writes to the active global profile", () => {
+        writeGlobalRaw({ profiles: { org_a: profile("Acme", "ltk_a") }, active_org: "org_a" });
+        const result = setSelectedWorkspace("wsp_new");
+        expect(result).toEqual({ scope: "global", orgId: "org_a" });
+        expect(loadGlobalConfig().profiles.org_a.workspace_id).toBe("wsp_new");
+    });
+    it("setSelectedWorkspace writes to a local pin when present", () => {
+        writeGlobalRaw({ profiles: { org_b: profile("Beta", "ltk_b") }, active_org: "org_a" });
+        writeLocalRaw({ active_org: "org_b" });
+        const result = setSelectedWorkspace("wsp_pinned");
+        expect(result).toMatchObject({ scope: "local", orgId: "org_b" });
+        expect(loadConfig("local").workspace_id).toBe("wsp_pinned");
+        expect(loadGlobalConfig().profiles.org_b.workspace_id).toBeUndefined();
+    });
+    it("setSelectedWorkspace returns null when there is nowhere to persist it", () => {
+        // No local pin, no active global profile (e.g. creds came from --api-key).
+        expect(setSelectedWorkspace("wsp_x")).toBeNull();
+    });
+});

package/dist/dev/wrapper_page.js

@@ -145,6 +145,20 @@ export function buildWrapperPage(args) {
         return completed.file;
       }
 
+      // openExternal — the wrapper page is the top frame (un-sandboxed), so it
+      // opens the link directly; NOT forwarded to the RPC endpoint (no server
+      // op). Re-validate the scheme; never trust the iframe's payload.
+      function handleOpenExternal(payload) {
+        var url = payload && payload.url;
+        if (typeof url !== "string") throw new Error("openExternal requires a url string");
+        var parsed = new URL(url);
+        if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+          throw new Error('openExternal: unsupported URL scheme "' + parsed.protocol + '"');
+        }
+        window.open(parsed.href, "_blank", "noopener,noreferrer");
+        return undefined;
+      }
+
       window.addEventListener("message", async function (event) {
         if (event.source !== iframe.contentWindow || event.origin !== VITE_ORIGIN) return;
         const msg = event.data;
@@ -153,6 +167,8 @@ export function buildWrapperPage(args) {
         try {
           const data = msg.op === "upload"
             ? await handleUpload(msg.payload)
+            : msg.op === "openExternal"
+            ? handleOpenExternal(msg.payload)
             : await rpc(msg.op, msg.payload);
           const ms = Math.round(performance.now() - startedAt);
           console.debug("[lotics-dev] " + msg.op + " " + ms + "ms", data);