@satori-sh/cli 0.0.12 → 0.0.14

package/dist/index.js

@@ -3,8 +3,9 @@
 // src/index.ts
 import { Command } from "commander";
 import { readFileSync, realpathSync } from "fs";
-import { dirname, join as join2 } from "path";
-import { fileURLToPath } from "url";
+import { execFile } from "child_process";
+import { dirname as dirname2, join as join3 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 import chalk from "chalk";
 
 // src/config.ts
@@ -35,6 +36,13 @@ async function saveApiKey(apiKey) {
     throw new Error(`Failed to save API key: ${error instanceof Error ? error.message : error}`);
   }
 }
+async function getStoredApiKey() {
+  const data = await loadConfigFile();
+  if (typeof data.api_key === "string") {
+    return data.api_key;
+  }
+  return null;
+}
 async function saveMemoryId(memoryId) {
   const { promises: fs } = await import("fs");
   await checkWriteAccess();
@@ -66,6 +74,7 @@ async function getConfig() {
   }
   let apiKey = null;
   let memoryId = void 0;
+  const openaiApiKey = process.env.OPENAI_API_KEY || null;
   try {
     const data = await loadConfigFile();
     if (typeof data.api_key === "string") {
@@ -79,12 +88,21 @@ async function getConfig() {
   if (!apiKey) {
     apiKey = process.env.SATORI_API_KEY || null;
   }
-  const baseUrl = process.env.SATORI_BASE_URL || "https://api.satori.sh";
+  const nodeEnv = process.env.NODE_ENV;
+  const baseUrl = process.env.SATORI_BASE_URL || (nodeEnv !== "production" ? "http://localhost:8000" : "https://api.satori.sh");
+  const checkoutUrl = process.env.SATORI_CHECKOUT_URL || (nodeEnv === "production" ? "https://buy.stripe.com/aFabJ03GIez6bH53Ckew800" : "https://buy.stripe.com/test_14AeVc5TZc2GapagZp0gw00");
   try {
     new URL(baseUrl);
   } catch {
     throw new Error("Invalid SATORI_BASE_URL format");
   }
+  if (checkoutUrl) {
+    try {
+      new URL(checkoutUrl);
+    } catch {
+      throw new Error("Invalid SATORI_CHECKOUT_URL format");
+    }
+  }
   if (!apiKey) {
     try {
       const response = await fetch(`${baseUrl}/orgs`, {
@@ -104,14 +122,10 @@ async function getConfig() {
       throw new Error(`Failed to generate API key: ${error instanceof Error ? error.message : error}`);
     }
   }
-  const provider = process.env.SATORI_PROVIDER || "openai";
-  const model = process.env.SATORI_MODEL || "gpt-4o";
-  const openaiKey = process.env.OPENAI_API_KEY;
-  const anthropicKey = process.env.ANTHROPIC_API_KEY;
   if (!memoryId) {
     memoryId = process.env.SATORI_MEMORY_ID;
   }
-  return { apiKey, baseUrl, provider, model, openaiKey, anthropicKey, memoryId };
+  return { apiKey, openaiApiKey, baseUrl, checkoutUrl, memoryId };
 }
 
 // src/search.ts
@@ -130,6 +144,10 @@ async function searchMemories(query) {
       },
       body: JSON.stringify({ query })
     });
+    if (response.status === 402) {
+      console.error("Free tier exceeded. Run `npx @satori-sh sub` to subscribe");
+      return;
+    }
     if (!response.ok) {
       console.error(`HTTP error: ${response.status} ${response.statusText}`);
       return;
@@ -156,6 +174,10 @@ async function addMemories(text, options = {}) {
       },
       body: JSON.stringify({ messages: [{ role: "user", content: text }], ...options.memoryId && { memory_id: options.memoryId } })
     });
+    if (response.status === 402) {
+      console.error("Free tier exceeded. Run `npx @satori-sh sub` to subscribe");
+      return;
+    }
     if (!response.ok) {
       console.error(`HTTP error: ${response.status} ${response.statusText}`);
       return;
@@ -168,7 +190,7 @@ async function addMemories(text, options = {}) {
 
 // src/memory.ts
 import { generate } from "random-words";
-async function buildMemoryContext(prompt, options = {}) {
+async function resolveMemoryId(options = {}) {
   const config = await getConfig();
   let memoryId;
   let generated = false;
@@ -183,37 +205,13 @@ async function buildMemoryContext(prompt, options = {}) {
     memoryId = words.join("-");
     generated = true;
   }
-  const topK = options.topK || 5;
-  const url = `${config.baseUrl}/search`;
-  const headers = {
-    "Content-Type": "application/json",
-    "Authorization": `Bearer ${config.apiKey}`
-  };
-  const body = JSON.stringify({
-    query: prompt,
-    memory_id: memoryId,
-    top_k: topK
-  });
-  const response = await fetch(url, {
-    method: "POST",
-    headers,
-    body
-  });
-  if (!response.ok) {
-    throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
   const instruction = generated ? `Memory session id: ${memoryId}.` : void 0;
   if (generated) {
     saveMemoryId(memoryId).catch((err) => {
       console.error("Failed to save memory ID:", err);
     });
   }
-  return {
-    results: data.results,
-    memoryId,
-    instruction
-  };
+  return { memoryId, instruction };
 }
 function enhanceMessagesWithMemory(messages, memoryContext) {
   const validResults = memoryContext.results.filter((r) => r.memory && r.memory.trim() !== "" && r.memory !== "undefined");
@@ -229,159 +227,373 @@ ${memoryText}`
   return [systemMessage, ...messages];
 }
 
-// src/providers.ts
-async function _callOpenAI(messages, options) {
-  const config = await getConfig();
-  const apiKey = config.openaiKey;
-  if (!apiKey) {
-    throw new Error("Missing API key for OPENAI_API_KEY");
-  }
-  const url = "https://api.openai.com/v1/chat/completions";
-  const body = {
-    model: config.model,
-    messages,
-    temperature: options.temperature ?? 0.7,
-    max_tokens: options.maxTokens ?? 1e3,
-    stream: options.stream ?? false
-  };
-  const headers = {
-    "Content-Type": "application/json",
-    "Authorization": `Bearer ${apiKey}`
-  };
-  const response = await fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  return data.choices[0].message.content;
+// src/ui.tsx
+import { render, useRenderer, useTerminalDimensions } from "@opentui/solid";
+import { For, Show, createSignal, onMount, onCleanup } from "solid-js";
+import cliSpinners from "cli-spinners";
+
+// src/logo.ts
+import { dirname, join as join2 } from "path";
+import { fileURLToPath } from "url";
+async function loadLogo() {
+  const { default: fs } = await import("fs");
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const logoPath = join2(__dirname, "..", "logos", "satori.ans");
+  return fs.readFileSync(logoPath, "utf8");
 }
-async function _callAnthropic(messages, options) {
-  const config = await getConfig();
-  const apiKey = config.anthropicKey;
-  if (!apiKey) {
-    throw new Error("Missing API key for ANTHROPIC_API_KEY");
-  }
-  const url = "https://api.anthropic.com/v1/messages";
-  const body = {
-    model: config.model,
-    messages,
-    temperature: options.temperature ?? 0.7,
-    max_tokens: options.maxTokens ?? 1e3,
-    stream: options.stream ?? false
+
+// src/ui.tsx
+async function runInteractiveApp({
+  initialPrompt,
+  options,
+  processUserInput,
+  infoLine,
+  infoDisplay
+}) {
+  const logo = await loadLogo();
+  console.log(` ${logo}`);
+  const rows = process.stdout.rows ?? 24;
+  const logoHeight = logo.endsWith("\n") ? logo.slice(0, -1).split("\n").length : logo.split("\n").length;
+  const splitHeight = Math.max(1, rows - logoHeight - 1);
+  render(
+    () => /* @__PURE__ */ React.createElement(
+      App,
+      {
+        initialPrompt,
+        options,
+        processUserInput,
+        infoLine,
+        infoDisplay
+      }
+    ),
+    {
+      useAlternateScreen: false,
+      exitOnCtrlC: true,
+      useMouse: true,
+      enableMouseMovement: true,
+      experimental_splitHeight: splitHeight
+    }
+  );
+}
+function App({ initialPrompt, options, processUserInput, infoLine, infoDisplay }) {
+  const renderer = useRenderer();
+  const dimensions = useTerminalDimensions();
+  const [messages, setMessages] = createSignal([]);
+  const [inputValue, setInputValue] = createSignal("");
+  const [showIntro, setShowIntro] = createSignal(true);
+  const [isFullScreen, setIsFullScreen] = createSignal(false);
+  const [spinnerFrame, setSpinnerFrame] = createSignal(0);
+  const [isLoading, setIsLoading] = createSignal(false);
+  const promptFg = "#00ffff";
+  const responseFg = "#ffffff";
+  const promptBg = "#2b2b2b";
+  let inputRef;
+  let currentMemoryId = options.memoryId;
+  let messageId = 0;
+  const usageText = infoDisplay?.usageLine ?? infoLine ?? "";
+  const versionText = infoDisplay?.versionLine ?? "";
+  const modelText = infoDisplay?.modelLine ?? "";
+  const appendMessage = (role, text) => {
+    setMessages((prev) => [...prev, { id: messageId++, role, text }]);
+  };
+  const exitApp = () => {
+    renderer.destroy();
+    process.exit(0);
   };
-  const headers = {
-    "Content-Type": "application/json",
-    "Authorization": `Bearer ${apiKey}`,
-    "anthropic-version": "2023-06-01"
+  const submitPrompt = async (raw) => {
+    const trimmed = raw.trim();
+    if (!trimmed) return;
+    if (trimmed.toLowerCase() === "exit" || trimmed.toLowerCase() === "quit") {
+      exitApp();
+      return;
+    }
+    if (showIntro()) {
+      setShowIntro(false);
+    }
+    if (!isFullScreen()) {
+      setIsFullScreen(true);
+    }
+    setInputValue("");
+    if (inputRef) {
+      inputRef.value = "";
+    }
+    appendMessage("prompt", trimmed);
+    try {
+      setIsLoading(true);
+      const result = await processUserInput(trimmed, { ...options, memoryId: currentMemoryId }, "tui");
+      currentMemoryId = result.memoryId;
+      appendMessage("response", result.response);
+      if (result.instruction) {
+        appendMessage("response", result.instruction);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      appendMessage("response", `Error: ${message}`);
+    } finally {
+      setIsLoading(false);
+    }
   };
-  const response = await fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
+  onMount(async () => {
+    const spinner = cliSpinners.dots;
+    const timer = setInterval(() => {
+      if (isLoading()) {
+        setSpinnerFrame((prev) => (prev + 1) % spinner.frames.length);
+      }
+    }, spinner.interval);
+    onCleanup(() => clearInterval(timer));
+    if (initialPrompt) {
+      await submitPrompt(initialPrompt);
+    }
+    if (inputRef) {
+      inputRef.focus();
+    }
   });
-  if (!response.ok) {
-    throw new Error(`Anthropic API error: ${response.status} ${response.statusText}`);
-  }
-  const data = await response.json();
-  return data.content[0].text;
-}
-async function _callProviderAPI(messages, options, provider) {
-  if (provider === "openai") {
-    return _callOpenAI(messages, options);
-  } else if (provider === "anthropic") {
-    return _callAnthropic(messages, options);
-  } else {
-    throw new Error(`Unsupported provider: ${provider}`);
-  }
+  const inputBoxWidth = () => Math.max(1, Math.round(dimensions().width * 0.6));
+  const inputBoxLeft = () => Math.max(0, Math.round(dimensions().width * 0.15));
+  const inputBoxHeight = () => isFullScreen() ? 7 : 14;
+  const inputBoxTop = () => isFullScreen() ? Math.max(1, dimensions().height - inputBoxHeight() - 2) : Math.max(1, Math.round(dimensions().height * 0.666));
+  const messagesTop = () => 1;
+  const messagesHeight = () => Math.max(1, inputBoxTop() - messagesTop() - 1);
+  const messagesWidth = () => Math.min(dimensions().width - 2, inputBoxWidth() + 10);
+  const messagesLeft = () => Math.max(1, inputBoxLeft() - 5);
+  return /* @__PURE__ */ React.createElement("box", { width: "100%", height: "100%", flexDirection: "column" }, /* @__PURE__ */ React.createElement(
+    "scrollbox",
+    {
+      id: "messages",
+      width: messagesWidth(),
+      height: messagesHeight(),
+      position: "absolute",
+      left: messagesLeft(),
+      top: messagesTop(),
+      paddingLeft: 1,
+      paddingRight: 1,
+      focused: true,
+      stickyScroll: true,
+      stickyStart: "bottom"
+    },
+    /* @__PURE__ */ React.createElement("box", { width: "100%", flexDirection: "column" }, /* @__PURE__ */ React.createElement(For, { each: messages() }, (message) => /* @__PURE__ */ React.createElement(
+      "box",
+      {
+        width: "100%",
+        flexDirection: "row",
+        justifyContent: message.role === "prompt" ? "flex-start" : "flex-end",
+        marginBottom: 1
+      },
+      /* @__PURE__ */ React.createElement(
+        "box",
+        {
+          paddingLeft: 1,
+          paddingRight: 1,
+          paddingTop: 1,
+          paddingBottom: 1,
+          backgroundColor: message.role === "prompt" ? promptBg : void 0
+        },
+        /* @__PURE__ */ React.createElement(
+          "text",
+          {
+            fg: message.role === "prompt" ? promptFg : responseFg,
+            width: "100%",
+            wrapMode: "word",
+            selectable: false
+          },
+          message.text
+        )
+      )
+    )))
+  ), /* @__PURE__ */ React.createElement(
+    "box",
+    {
+      id: "input-box",
+      width: inputBoxWidth(),
+      height: inputBoxHeight(),
+      position: "absolute",
+      left: inputBoxLeft(),
+      top: inputBoxTop(),
+      paddingLeft: 1,
+      paddingRight: 1,
+      paddingTop: 1,
+      flexDirection: "column"
+    },
+    /* @__PURE__ */ React.createElement(For, { each: !isFullScreen() && showIntro() ? [
+      "Use Satori just like you would use ChatGPT.",
+      "Except, it stores your conversations in a long term memory.",
+      "The memories you store here can be accessed through the SDK."
+    ] : [] }, (line) => /* @__PURE__ */ React.createElement("text", { fg: "cyan" }, line)),
+    /* @__PURE__ */ React.createElement(
+      "box",
+      {
+        id: "input-box",
+        width: inputBoxWidth(),
+        height: 5,
+        backgroundColor: "#1a1a1a",
+        flexDirection: "column",
+        justifyContent: "center"
+      },
+      /* @__PURE__ */ React.createElement(
+        "input",
+        {
+          id: "input",
+          width: "100%",
+          height: 1,
+          placeholder: "Type a message and press Enter...",
+          focusedBackgroundColor: "#1a1a1a",
+          onInput: (value) => setInputValue(value),
+          onSubmit: () => submitPrompt(inputValue()),
+          ref: (r) => {
+            inputRef = r;
+          }
+        }
+      ),
+      /* @__PURE__ */ React.createElement("box", { flexDirection: "row", flexShrink: 0, paddingTop: 1 }, /* @__PURE__ */ React.createElement("text", { fg: "#ffffff" }, modelText))
+    )
+  ), /* @__PURE__ */ React.createElement(Show, { when: isLoading() }, /* @__PURE__ */ React.createElement(
+    "box",
+    {
+      id: "spinner",
+      position: "absolute",
+      left: inputBoxLeft(),
+      top: inputBoxTop() + inputBoxHeight(),
+      paddingLeft: 1
+    },
+    /* @__PURE__ */ React.createElement("text", { fg: "#00ffff" }, cliSpinners.dots.frames[spinnerFrame()])
+  )), /* @__PURE__ */ React.createElement(
+    "box",
+    {
+      id: "footer",
+      width: dimensions().width,
+      height: 1,
+      position: "absolute",
+      bottom: 0,
+      left: 0,
+      backgroundColor: "#000000",
+      paddingLeft: 1,
+      paddingRight: 1,
+      flexDirection: "row",
+      justifyContent: "space-between",
+      alignItems: "center"
+    },
+    /* @__PURE__ */ React.createElement("text", { fg: "#00ffff", wrapMode: "none", width: "100%" }, usageText),
+    /* @__PURE__ */ React.createElement("box", { flexShrink: 0, paddingLeft: 1 }, /* @__PURE__ */ React.createElement("text", { fg: "#00ffff" }, versionText))
+  ));
 }
 
 // src/index.ts
 async function main() {
-  try {
-    await getConfig();
-  } catch (error) {
-    console.error(error instanceof Error ? error.message : "Configuration error");
-    process.exit(1);
+  const argv = process.argv.slice(2);
+  const isGetApiKey = argv[0] === "get" && argv[1] === "api-key";
+  if (!isGetApiKey) {
+    try {
+      await getConfig();
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : "Configuration error");
+      process.exit(1);
+    }
   }
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  const logoPath = join2(__dirname, "..", "logo.txt");
-  console.log(chalk.cyan(readFileSync(logoPath, "utf8")));
   const program = new Command();
   program.name("satori").description("CLI tool for Satori memory server").version("0.0.1");
-  program.option("--provider <provider>", "Provider to use (openai or anthropic)", "openai").option("--model <model>", "Model to use", "gpt-4o").option("--memory-id <id>", "Memory ID for scoping");
-  const processUserInput = async (input, options, isInteractive = false) => {
-    let memoryContext;
+  program.option("--memory-id <id>", "Memory ID for scoping");
+  const DEFAULT_LLM_MODEL = "gpt-4o";
+  const getCliVersion = () => {
+    const __dirname = dirname2(fileURLToPath2(import.meta.url));
+    const packagePath = join3(__dirname, "..", "package.json");
+    const raw = readFileSync(packagePath, "utf8");
+    const data = JSON.parse(raw);
+    return data.version ?? "unknown";
+  };
+  const fetchOrgUsage = async () => {
     try {
-      memoryContext = await buildMemoryContext(input, { memoryId: options.memoryId });
-    } catch (memoryError) {
-      memoryContext = { results: [], memoryId: options.memoryId, instruction: void 0 };
+      const config = await getConfig();
+      const response = await fetch(`${config.baseUrl}/org/usage`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${config.apiKey}`
+        }
+      });
+      if (!response.ok) {
+        return null;
+      }
+      return await response.json();
+    } catch {
+      return null;
     }
-    const userMessage = { role: "user", content: input };
-    const enhancedMessages = enhanceMessagesWithMemory([userMessage], { results: memoryContext.results });
-    const response = await _callProviderAPI(enhancedMessages, {
-      temperature: 0.7,
-      maxTokens: 1e3
-    }, options.provider);
-    if (isInteractive) {
-      console.log(`Assistant: ${response}`);
-    } else {
-      console.log(response);
+  };
+  const getInfoDisplay = async () => {
+    const usage = await fetchOrgUsage();
+    const tokens = usage ? usage.total_tokens.toLocaleString() : "unknown";
+    const memoryId = usage?.memory_id ?? "unknown";
+    const version = getCliVersion();
+    return {
+      usageLine: `Tokens Used ${tokens} | Memory Layer: ${memoryId}`,
+      versionLine: `${version}`,
+      modelLine: `Model: ${DEFAULT_LLM_MODEL}`,
+      fullLine: `Model: ${DEFAULT_LLM_MODEL} | Tokens: ${tokens} | Memory ID: ${memoryId} | CLI: ${version}`
+    };
+  };
+  const callAskAPI = async (prompt, memoryId) => {
+    const config = await getConfig();
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${config.apiKey}`
+    };
+    if (config.openaiApiKey) {
+      headers["X-OpenAI-Key"] = config.openaiApiKey;
     }
-    if (memoryContext.instruction) {
-      console.log(`
-${memoryContext.instruction}`);
+    const response = await fetch(`${config.baseUrl}/ask`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        prompt,
+        memory_id: memoryId,
+        llm_model: DEFAULT_LLM_MODEL
+      })
+    });
+    if (response.status === 402) {
+      console.error("Free tier exceeded. Run `npx @satori-sh sub` to subscribe");
+      process.exit(1);
     }
-    addMemories(input, { memoryId: memoryContext.memoryId }).catch((err) => {
+    if (!response.ok) {
+      throw new Error(`HTTP error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.response;
+  };
+  const processUserInput = async (input, options, outputMode) => {
+    const { memoryId, instruction } = await resolveMemoryId({ memoryId: options.memoryId });
+    const response = await callAskAPI(input, memoryId);
+    if (outputMode === "cli") {
+      console.log(response);
+      if (instruction) {
+        console.log(`
+${instruction}`);
+      }
+    }
+    addMemories(input, { memoryId }).catch((err) => {
       console.error("Failed to save memory:", err);
     });
-    return { response, instruction: memoryContext.instruction, memoryId: memoryContext.memoryId };
+    return { response, instruction, memoryId };
   };
   program.argument("[prompt]", "initial prompt for chat session (optional)").action(async (initialPrompt, options) => {
     try {
-      let memoryId = options.memoryId;
-      if (!process.stdin.isTTY) {
+      if (!process.stdin.isTTY || !process.stdout.isTTY) {
         if (initialPrompt) {
-          await processUserInput(initialPrompt, options, false);
+          const info2 = await getInfoDisplay();
+          console.log(info2.fullLine);
+          await processUserInput(initialPrompt, options, "cli");
         }
         return;
       }
-      if (initialPrompt) {
-        const result = await processUserInput(initialPrompt, options, true);
-        memoryId = result.memoryId;
-      }
-      const { createInterface } = await import("readline");
-      const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout
+      const info = await getInfoDisplay();
+      await runInteractiveApp({
+        initialPrompt,
+        options,
+        processUserInput,
+        infoLine: info.fullLine,
+        infoDisplay: {
+          usageLine: info.usageLine,
+          versionLine: info.versionLine,
+          modelLine: info.modelLine
+        }
       });
-      const chatLoop = async () => {
-        rl.question(chalk.cyan("> "), async (input) => {
-          if (input.toLowerCase() === "exit" || input.toLowerCase() === "quit") {
-            console.log("Goodbye!");
-            rl.close();
-            return;
-          }
-          if (!input.trim()) {
-            chatLoop();
-            return;
-          }
-          try {
-            const result = await processUserInput(input, { ...options, memoryId }, true);
-            memoryId = result.memoryId;
-          } catch (error) {
-            console.error("Chat error:", error instanceof Error ? error.message : error);
-          }
-          chatLoop();
-        });
-      };
-      console.log(chalk.magenta("\nSatori is memory for AI. It remembers your sessions forever. Think of it like 'infinite context' for AI.\n"));
-      console.log(chalk.cyan("You're in interactive mode. Use interactive mode just like you would use ChatGPT."));
-      console.log(chalk.cyan('Type "exit" or "quit" to end the session.\n'));
-      chatLoop();
     } catch (error) {
       console.error("Chat error:", error instanceof Error ? error.message : error);
       process.exit(1);
@@ -393,10 +605,51 @@ ${memoryContext.instruction}`);
   program.command("search").description("search memories").argument("<query>", "search query for memories").action(async (query) => {
     await searchMemories(query);
   });
+  program.command("sub").description("open the subscription checkout").action(async () => {
+    const config = await getConfig();
+    const checkoutUrlRaw = config.checkoutUrl;
+    if (!checkoutUrlRaw) {
+      console.error("SATORI_CHECKOUT_URL is not set");
+      process.exit(1);
+    }
+    let checkoutUrl;
+    try {
+      checkoutUrl = new URL(checkoutUrlRaw).toString();
+    } catch {
+      console.error("SATORI_CHECKOUT_URL is not a valid URL");
+      process.exit(1);
+    }
+    if (process.platform !== "darwin") {
+      console.log(checkoutUrl);
+      return;
+    }
+    await new Promise((resolve) => {
+      execFile("open", [checkoutUrl], (error) => {
+        if (error) {
+          console.log(checkoutUrl);
+        }
+        resolve();
+      });
+    });
+  });
+  program.command("get").description("get config value (e.g. `get api-key`)").argument("<key>", "key to get").action(async (key) => {
+    if (key !== "api-key") {
+      console.error("Unknown key");
+      process.exit(1);
+    }
+    const apiKey = await getStoredApiKey();
+    if (!apiKey) {
+      console.error("API key not found in config");
+      process.exit(1);
+    }
+    console.log(chalk.magenta(`
+    ${apiKey}    
+`));
+  });
   program.parse();
 }
 var entryPath = process.argv[1] ? realpathSync(process.argv[1]) : "";
-var modulePath = realpathSync(fileURLToPath(import.meta.url));
+var modulePath = realpathSync(fileURLToPath2(import.meta.url));
 if (entryPath === modulePath) {
   main();
 }