limbo-ai 1.5.0 → 1.6.1

package/cli.js

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 // cli.js — Limbo CLI
 // Orchestrates the Docker-based Limbo runtime.
-// Zero npm dependencies — pure Node.js stdlib.
 'use strict';
 
 const { execSync, spawnSync } = require('child_process');
@@ -14,10 +13,11 @@ const readline = require('readline');
 // ─── Config ──────────────────────────────────────────────────────────────────
 
 const LIMBO_DIR = path.join(os.homedir(), '.limbo');
+const VAULT_DIR = path.join(LIMBO_DIR, 'vault');
 const ENV_FILE = path.join(LIMBO_DIR, '.env');
 const COMPOSE_FILE = path.join(LIMBO_DIR, 'docker-compose.yml');
 const GHCR_IMAGE = 'ghcr.io/tomasward1/limbo';
-const DEFAULT_TAG = 'latest';
+const DEFAULT_TAG = require('./package.json').version;
 const PORT = 18789;
 
 // OpenClaw compatibility snapshots from official docs:
@@ -68,6 +68,7 @@ const COMPOSE_CONTENT = `services:
       - "127.0.0.1:${PORT}:${PORT}"
     volumes:
       - limbo-data:/data
+      - ./vault:/data/vault
       - limbo-openclaw-state:/home/limbo/.openclaw
     env_file:
       - .env
@@ -278,6 +279,22 @@ function sleep(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
+let clackPromise;
+
+async function getClack() {
+  if (!clackPromise) clackPromise = import('@clack/prompts');
+  return clackPromise;
+}
+
+async function maybeHandleClackCancel(value) {
+  const { cancel, isCancel } = await getClack();
+  if (isCancel(value)) {
+    cancel('Setup cancelled.');
+    process.exit(130);
+  }
+  return value;
+}
+
 function hasDocker() {
   const result = spawnSync('docker', ['compose', 'version'], { stdio: 'pipe' });
   return result.status === 0;
@@ -311,25 +328,34 @@ function createPromptInterface() {
   return readline.createInterface({ input: process.stdin, output: process.stdout });
 }
 
-async function promptValidated(rl, question, validate, errorMessage) {
+async function promptValidated(question, validate, errorMessage) {
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    const { text } = await getClack();
+    while (true) {
+      const value = await maybeHandleClackCancel(await text({
+        message: question.trim(),
+        validate: (input) => {
+          const validation = validate(String(input ?? ''));
+          return validation.ok ? undefined : (validation.message || errorMessage);
+        },
+      }));
+      const validation = validate(String(value));
+      if (validation.ok) return validation.value;
+    }
+  }
+
+  const rl = createPromptInterface();
   while (true) {
     const value = (await prompt(rl, question)).trim();
     const validation = validate(value);
-    if (validation.ok) return validation.value;
+    if (validation.ok) {
+      rl.close();
+      return validation.value;
+    }
     warn(validation.message || errorMessage);
   }
 }
 
-function renderMenu(question, options, selectedIndex, lang) {
-  const lines = [`${c.bold}${question}${c.reset}`, `${c.dim}${t(lang, 'menuHelp')}${c.reset}`, ''];
-  options.forEach((option, index) => {
-    const prefix = index === selectedIndex ? `${c.green}>${c.reset}` : ' ';
-    lines.push(`${prefix} ${option.label}`);
-    if (option.description) lines.push(`   ${c.dim}${option.description}${c.reset}`);
-  });
-  return lines.join('\n');
-}
-
 async function selectMenu(question, options, lang) {
   if (!process.stdin.isTTY || !process.stdout.isTTY || typeof process.stdin.setRawMode !== 'function') {
     const rl = createPromptInterface();
@@ -345,56 +371,16 @@ async function selectMenu(question, options, lang) {
       warn('Pick one of the listed options.');
     }
   }
-
-  return new Promise((resolve) => {
-    let selectedIndex = 0;
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    readline.emitKeypressEvents(process.stdin, rl);
-    const previousRawMode = process.stdin.isRaw;
-    process.stdin.setRawMode(true);
-
-    function cleanup() {
-      process.stdin.off('keypress', onKeypress);
-      process.stdin.setRawMode(Boolean(previousRawMode));
-      rl.close();
-      process.stdout.write('\n');
-    }
-
-    function draw() {
-      readline.cursorTo(process.stdout, 0);
-      readline.clearScreenDown(process.stdout);
-      process.stdout.write(`${renderMenu(question, options, selectedIndex, lang)}\n`);
-    }
-
-    function onKeypress(_, key = {}) {
-      if (key.name === 'up' || key.name === 'k') {
-        selectedIndex = selectedIndex === 0 ? options.length - 1 : selectedIndex - 1;
-        draw();
-        return;
-      }
-
-      if (key.name === 'down' || key.name === 'j') {
-        selectedIndex = selectedIndex === options.length - 1 ? 0 : selectedIndex + 1;
-        draw();
-        return;
-      }
-
-      if (key.name === 'return') {
-        const value = options[selectedIndex];
-        cleanup();
-        resolve(value);
-        return;
-      }
-
-      if (key.ctrl && key.name === 'c') {
-        cleanup();
-        process.exit(130);
-      }
-    }
-
-    process.stdin.on('keypress', onKeypress);
-    draw();
-  });
+  const { select } = await getClack();
+  const selectedValue = await maybeHandleClackCancel(await select({
+    message: question,
+    options: options.map((option) => ({
+      value: option.value,
+      label: option.label,
+      hint: option.description,
+    })),
+  }));
+  return options.find((option) => option.value === selectedValue) || options[0];
 }
 
 function parseEnvFile() {
@@ -504,14 +490,11 @@ async function collectConfig(existingEnv = {}) {
 
   const modelName = await chooseModel(language, providerFamily, accessMethod);
   const provider = getModelCatalog(providerFamily, accessMethod).provider;
-
-  const rl = createPromptInterface();
   let apiKey = '';
 
   if (accessMethod === 'api-key') {
     if (providerFamily === 'openai') {
       apiKey = await promptValidated(
-        rl,
         t(language, 'openAiApiKeyPrompt'),
         (value) => {
           if (!value) return { ok: false, message: t(language, 'requiredField') };
@@ -521,7 +504,6 @@ async function collectConfig(existingEnv = {}) {
       );
     } else {
       apiKey = await promptValidated(
-        rl,
         t(language, 'anthropicApiKeyPrompt'),
         (value) => {
           if (!value) return { ok: false, message: t(language, 'requiredField') };
@@ -540,14 +522,11 @@ async function collectConfig(existingEnv = {}) {
   let telegramToken = '';
   if (telegramChoice.value === 'true') {
     telegramToken = await promptValidated(
-      rl,
       t(language, 'telegramTokenPrompt'),
       (value) => value ? { ok: true, value } : { ok: false, message: t(language, 'requiredField') },
     );
   }
 
-  rl.close();
-
   return {
     language,
     authMode: accessMethod,
@@ -563,6 +542,8 @@ async function collectConfig(existingEnv = {}) {
 
 function ensureComposeFile() {
   fs.mkdirSync(LIMBO_DIR, { recursive: true });
+  fs.mkdirSync(path.join(VAULT_DIR, 'notes'), { recursive: true });
+  fs.mkdirSync(path.join(VAULT_DIR, 'maps'), { recursive: true });
   fs.writeFileSync(COMPOSE_FILE, COMPOSE_CONTENT);
 }
 
@@ -674,6 +655,7 @@ ${c.green}${c.bold}╚═══════════════════
   ${c.bold}${t(cfg.language, 'gateway')}:${c.reset}        ws://127.0.0.1:${PORT}
   ${c.bold}${t(cfg.language, 'gatewayToken')}:${c.reset}  ${gatewayToken}
   ${c.bold}${t(cfg.language, 'data')}:${c.reset}           ${LIMBO_DIR}
+  ${c.bold}Vault:${c.reset}          ${VAULT_DIR}
   ${c.bold}${t(cfg.language, 'logs')}:${c.reset}           limbo logs
   ${c.bold}${t(cfg.language, 'stop')}:${c.reset}           limbo stop
   ${c.bold}${t(cfg.language, 'update')}:${c.reset}         limbo update

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "limbo-ai",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "description": "Your personal AI memory agent — install and manage Limbo via npx",
   "type": "commonjs",
   "bin": {
@@ -9,6 +9,9 @@
   "engines": {
     "node": ">=18"
   },
+  "dependencies": {
+    "@clack/prompts": "^1.1.0"
+  },
   "scripts": {
     "start": "node cli.js start"
   },