@satori-sh/cli 0.0.13 → 0.0.14

package/README.md

@@ -37,6 +37,13 @@ Add new memories:
 satori add "I like pizza"
 ```
 
+### Subscribe
+
+Open checkout in the browser:
+```bash
+npx @satori-sh sub
+```
+
 **Options & Memory:**
 - `--memory-id <id>` (scopes conversations)
 
@@ -53,8 +60,16 @@ satori chat "Follow up question"
 
 **Optional:**
 - `SATORI_BASE_URL` (default: http://localhost:8000)
+- `SATORI_CHECKOUT_URL` - Stripe checkout link for `npx @satori-sh sub`
 - `SATORI_MEMORY_ID` - Session scoping
 - `SATORI_MOCK` - Enable mock mode
+- `OPENAI_API_KEY` - Pass-through OpenAI key for `/ask` (sent as `X-OpenAI-Key`)
+- `NODE_ENV` - Set to `development` to default to `http://localhost:8000`
+
+Example:
+```bash
+NODE_ENV=development bun run src/index.ts
+```
 
 ## Troubleshooting
 

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
@@ -73,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") {
@@ -86,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`, {
@@ -114,7 +125,7 @@ async function getConfig() {
   if (!memoryId) {
     memoryId = process.env.SATORI_MEMORY_ID;
   }
-  return { apiKey, baseUrl, memoryId };
+  return { apiKey, openaiApiKey, baseUrl, checkoutUrl, memoryId };
 }
 
 // src/search.ts
@@ -133,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;
@@ -159,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;
@@ -208,10 +227,260 @@ ${memoryText}`
   return [systemMessage, ...messages];
 }
 
+// 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");
+}
+
+// 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 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);
+    }
+  };
+  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();
+    }
+  });
+  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() {
   const argv = process.argv.slice(2);
-  const isGetApiKey = argv[0] === "get" && argv[1] === "apikey";
+  const isGetApiKey = argv[0] === "get" && argv[1] === "api-key";
   if (!isGetApiKey) {
     try {
       await getConfig();
@@ -220,44 +489,83 @@ async function main() {
       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("--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 {
+      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 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;
+    }
     const response = await fetch(`${config.baseUrl}/ask`, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${config.apiKey}`
-      },
+      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);
+    }
     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, isInteractive = false) => {
+  const processUserInput = async (input, options, outputMode) => {
     const { memoryId, instruction } = await resolveMemoryId({ memoryId: options.memoryId });
     const response = await callAskAPI(input, memoryId);
-    if (isInteractive) {
-      console.log(`Assistant: ${response}`);
-    } else {
+    if (outputMode === "cli") {
       console.log(response);
-    }
-    if (instruction) {
-      console.log(`
+      if (instruction) {
+        console.log(`
 ${instruction}`);
+      }
     }
     addMemories(input, { memoryId }).catch((err) => {
       console.error("Failed to save memory:", err);
@@ -266,54 +574,26 @@ ${instruction}`);
   };
   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 getPrompt = async () => {
-        if (!memoryId) {
-          const resolved = await resolveMemoryId({ memoryId: options.memoryId });
-          memoryId = resolved.memoryId;
+      const info = await getInfoDisplay();
+      await runInteractiveApp({
+        initialPrompt,
+        options,
+        processUserInput,
+        infoLine: info.fullLine,
+        infoDisplay: {
+          usageLine: info.usageLine,
+          versionLine: info.versionLine,
+          modelLine: info.modelLine
         }
-        return chalk.cyan(`[${memoryId}] > `);
-      };
-      const chatLoop = async () => {
-        const prompt = await getPrompt();
-        rl.question(prompt, 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);
@@ -325,8 +605,35 @@ ${instruction}`);
   program.command("search").description("search memories").argument("<query>", "search query for memories").action(async (query) => {
     await searchMemories(query);
   });
-  program.command("get").description("get config value").argument("<key>", "key to get").action(async (key) => {
-    if (key !== "apikey") {
+  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);
     }
@@ -342,7 +649,7 @@ ${instruction}`);
   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();
 }