@cognisos/liminal 0.2.0 → 2.2.0

package/dist/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/version.ts
-var VERSION = true ? "0.2.0" : "0.2.0";
+var VERSION = true ? "2.2.0" : "0.2.1";
 var BANNER_LINES = [
   " ___       ___  _____ ______   ___  ________   ________  ___",
   "|\\  \\     |\\  \\|\\   _ \\  _   \\|\\  \\|\\   ___  \\|\\   __  \\|\\  \\",
@@ -22,9 +22,11 @@ function printBanner() {
 }
 
 // src/commands/init.ts
-import { createInterface } from "readline/promises";
-import { stdin, stdout } from "process";
-import { RSCTransport, CircuitBreaker } from "@cognisos/rsc-sdk";
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as stdin2, stdout as stdout2 } from "process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, appendFileSync } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
 
 // src/config/loader.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
@@ -152,6 +154,10 @@ function parseKey(data) {
   if (data.length === 1 && data[0] === 27) return { type: "escape" };
   if (data[0] === 13 || data[0] === 10) return { type: "enter" };
   if (data[0] === 32) return { type: "space" };
+  if (data[0] === 127 || data[0] === 8) return { type: "backspace" };
+  if (data.length === 1 && data[0] >= 33 && data[0] <= 126) {
+    return { type: "char", char: String.fromCharCode(data[0]) };
+  }
   return { type: "other" };
 }
 function renderSelect(options, cursorIndex, message) {
@@ -189,18 +195,18 @@ function renderMultiSelect(options, cursorIndex, selected, message) {
   return { text: lines.join("\n"), lineCount: lines.length };
 }
 function withRawMode(streams, handler) {
-  const { stdin: stdin2, stdout: stdout2 } = streams;
+  const { stdin: stdin3, stdout: stdout3 } = streams;
   return new Promise((resolve, reject) => {
     let cleaned = false;
     function cleanup() {
       if (cleaned) return;
       cleaned = true;
-      stdin2.removeListener("data", onData);
-      if (stdin2.setRawMode) stdin2.setRawMode(false);
-      if ("pause" in stdin2 && typeof stdin2.pause === "function") {
-        stdin2.pause();
+      stdin3.removeListener("data", onData);
+      if (stdin3.setRawMode) stdin3.setRawMode(false);
+      if ("pause" in stdin3 && typeof stdin3.pause === "function") {
+        stdin3.pause();
       }
-      stdout2.write(ANSI.SHOW_CURSOR);
+      stdout3.write(ANSI.SHOW_CURSOR);
       process.removeListener("exit", cleanup);
     }
     function onData(data) {
@@ -217,11 +223,11 @@ function withRawMode(streams, handler) {
     });
     process.on("exit", cleanup);
     try {
-      if (stdin2.setRawMode) stdin2.setRawMode(true);
-      stdout2.write(ANSI.HIDE_CURSOR);
-      stdin2.on("data", onData);
-      if ("resume" in stdin2 && typeof stdin2.resume === "function") {
-        stdin2.resume();
+      if (stdin3.setRawMode) stdin3.setRawMode(true);
+      stdout3.write(ANSI.HIDE_CURSOR);
+      stdin3.on("data", onData);
+      if ("resume" in stdin3 && typeof stdin3.resume === "function") {
+        stdin3.resume();
       }
     } catch (err) {
       cleanup();
@@ -348,34 +354,279 @@ async function multiSelectPrompt(config) {
   }
   return result;
 }
+async function passwordPrompt(config) {
+  const { message, _streams } = config;
+  const streams = _streams ?? { stdin: process.stdin, stdout: process.stdout };
+  let password = "";
+  streams.stdout.write(`  ${ANSI.BOLD}${message}${ANSI.RESET}: `);
+  const result = await withRawMode(streams, (resolve) => {
+    return (key) => {
+      switch (key.type) {
+        case "char":
+          password += key.char;
+          streams.stdout.write("*");
+          break;
+        case "space":
+          password += " ";
+          streams.stdout.write("*");
+          break;
+        case "backspace":
+          if (password.length > 0) {
+            password = password.slice(0, -1);
+            streams.stdout.write("\b \b");
+          }
+          break;
+        case "enter":
+          streams.stdout.write("\n");
+          resolve(password);
+          break;
+        case "escape":
+          streams.stdout.write("\n");
+          resolve("");
+          break;
+      }
+    };
+  });
+  return result;
+}
+
+// src/commands/login.ts
+import { createInterface } from "readline/promises";
+import { stdin, stdout } from "process";
+
+// src/auth/supabase.ts
+import { randomBytes } from "crypto";
+var SUPABASE_URL = "https://nzcneiyymvgxvttbenhp.supabase.co";
+var SUPABASE_ANON_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Im56Y25laXl5bXZneHZ0dGJlbmhwIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NTQwNjQ0MjcsImV4cCI6MjA2OTY0MDQyN30.x3E-zGRadbPMmxRqT_PB_KOi00htKpgeb8GiQa4g2z0";
+function supabaseHeaders(accessToken) {
+  const headers = {
+    "Content-Type": "application/json",
+    "apikey": SUPABASE_ANON_KEY
+  };
+  if (accessToken) {
+    headers["Authorization"] = `Bearer ${accessToken}`;
+  }
+  return headers;
+}
+async function signIn(email, password) {
+  const res = await fetch(`${SUPABASE_URL}/auth/v1/token?grant_type=password`, {
+    method: "POST",
+    headers: supabaseHeaders(),
+    body: JSON.stringify({ email, password })
+  });
+  const body = await res.json();
+  if (!res.ok) {
+    const msg = body?.error_description || body?.error || body?.msg || "Authentication failed";
+    const err = { message: msg, status: res.status };
+    throw err;
+  }
+  return {
+    accessToken: body.access_token,
+    userId: body.user?.id,
+    email: body.user?.email ?? email
+  };
+}
+async function signUp(email, password, name) {
+  const res = await fetch(`${SUPABASE_URL}/auth/v1/signup`, {
+    method: "POST",
+    headers: supabaseHeaders(),
+    body: JSON.stringify({
+      email,
+      password,
+      data: { name }
+    })
+  });
+  const body = await res.json();
+  if (!res.ok) {
+    const msg = body?.error_description || body?.error || body?.msg || "Sign up failed";
+    const err = { message: msg, status: res.status };
+    throw err;
+  }
+  if (body.user?.identities?.length === 0) {
+    const err = { message: "Account already exists. Try logging in instead." };
+    throw err;
+  }
+  return {
+    accessToken: body.access_token,
+    userId: body.user?.id,
+    email: body.user?.email ?? email
+  };
+}
+async function fetchApiKey(accessToken, userId) {
+  const params = new URLSearchParams({
+    user_id: `eq.${userId}`,
+    is_active: "eq.true",
+    select: "api_key",
+    limit: "1"
+  });
+  const res = await fetch(`${SUPABASE_URL}/rest/v1/user_api_keys?${params}`, {
+    headers: supabaseHeaders(accessToken)
+  });
+  if (!res.ok) return null;
+  const rows = await res.json();
+  if (Array.isArray(rows) && rows.length > 0 && rows[0].api_key) {
+    return rows[0].api_key;
+  }
+  return null;
+}
+async function createApiKey(accessToken, userId) {
+  const apiKey = `fmcp_${randomBytes(32).toString("hex")}`;
+  const res = await fetch(`${SUPABASE_URL}/rest/v1/user_api_keys`, {
+    method: "POST",
+    headers: {
+      ...supabaseHeaders(accessToken),
+      "Prefer": "return=representation"
+    },
+    body: JSON.stringify({
+      user_id: userId,
+      key_name: "Liminal CLI",
+      api_key: apiKey,
+      is_active: true
+    })
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    const msg = body?.message || body?.error || "Failed to create API key";
+    throw { message: msg, status: res.status };
+  }
+  return apiKey;
+}
+async function authenticateAndGetKey(auth) {
+  const existingKey = await fetchApiKey(auth.accessToken, auth.userId);
+  if (existingKey) return existingKey;
+  return createApiKey(auth.accessToken, auth.userId);
+}
+
+// src/commands/login.ts
+async function loginCommand() {
+  printBanner();
+  try {
+    const config = loadConfig();
+    if (config.apiKey && config.apiKey.startsWith("fmcp_")) {
+      console.log("  Already logged in.");
+      console.log("  Run \x1B[1mliminal logout\x1B[0m first to switch accounts.");
+      return;
+    }
+  } catch {
+  }
+  await runAuthFlow();
+}
+async function runAuthFlow() {
+  const modeResult = await selectPrompt({
+    message: "Welcome to Liminal",
+    options: [
+      { label: "Log in", value: "login", description: "I have an account" },
+      { label: "Create account", value: "signup", description: "New to Liminal" }
+    ],
+    defaultIndex: 0
+  });
+  const mode = modeResult ?? "login";
+  console.log();
+  const rl = createInterface({ input: stdin, output: stdout });
+  let name = "";
+  let email;
+  try {
+    if (mode === "signup") {
+      name = (await rl.question("  \x1B[1mName\x1B[0m: ")).trim();
+      if (!name) {
+        console.error("\n  Error: Name is required.");
+        process.exit(1);
+      }
+    }
+    email = (await rl.question("  \x1B[1mEmail\x1B[0m: ")).trim();
+    if (!email) {
+      console.error("\n  Error: Email is required.");
+      process.exit(1);
+    }
+  } finally {
+    rl.close();
+  }
+  const password = await passwordPrompt({ message: "Password" });
+  if (!password) {
+    console.error("\n  Error: Password is required.");
+    process.exit(1);
+  }
+  console.log();
+  const action = mode === "signup" ? "Creating account" : "Logging in";
+  process.stdout.write(`  ${action}... `);
+  try {
+    const auth = mode === "signup" ? await signUp(email, password, name) : await signIn(email, password);
+    console.log("OK");
+    process.stdout.write("  Setting up API key... ");
+    const apiKey = await authenticateAndGetKey(auth);
+    console.log("OK");
+    ensureDirectories();
+    saveConfig({
+      apiKey,
+      apiBaseUrl: DEFAULTS.apiBaseUrl
+    });
+    console.log();
+    console.log(`  Logged in as \x1B[1m${auth.email}\x1B[0m`);
+    return apiKey;
+  } catch (err) {
+    console.log("FAILED");
+    const authErr = err;
+    console.error(`
+  ${authErr.message}`);
+    if (mode === "login" && authErr.message?.includes("Invalid login")) {
+      console.error("  Check your email and password, then try again.");
+    }
+    process.exit(1);
+  }
+}
 
 // src/commands/init.ts
-function printToolInstructions(tool, port) {
+function detectShellProfile() {
+  const shell = process.env.SHELL || "";
+  const home = homedir2();
+  if (shell.endsWith("/zsh")) {
+    const zshrc = join2(home, ".zshrc");
+    return { name: "~/.zshrc", path: zshrc };
+  }
+  if (shell.endsWith("/bash")) {
+    const bashProfile = join2(home, ".bash_profile");
+    if (existsSync2(bashProfile)) {
+      return { name: "~/.bash_profile", path: bashProfile };
+    }
+    return { name: "~/.bashrc", path: join2(home, ".bashrc") };
+  }
+  const candidates = [
+    { name: "~/.zshrc", path: join2(home, ".zshrc") },
+    { name: "~/.bashrc", path: join2(home, ".bashrc") },
+    { name: "~/.profile", path: join2(home, ".profile") }
+  ];
+  for (const c of candidates) {
+    if (existsSync2(c.path)) return c;
+  }
+  return null;
+}
+function getExportLines(tools, port) {
   const base = `http://127.0.0.1:${port}`;
-  switch (tool) {
-    case "claude-code":
-      console.log("    Claude Code:");
-      console.log(`      export ANTHROPIC_BASE_URL=${base}`);
-      console.log("      (Add to your shell profile for persistence)");
-      console.log();
-      break;
-    case "codex":
-      console.log("    Codex:");
-      console.log(`      export OPENAI_BASE_URL=${base}/v1`);
-      console.log("      (Add to your shell profile for persistence)");
-      console.log();
-      break;
-    case "cursor":
-      console.log("    Cursor:");
-      console.log(`      Settings > Models > OpenAI API Base URL: ${base}/v1`);
-      console.log();
-      break;
-    case "openai-compatible":
-      console.log("    OpenAI-compatible tools:");
-      console.log(`      Set your base URL to: ${base}/v1`);
-      console.log();
-      break;
+  const lines = [];
+  if (tools.includes("claude-code")) {
+    lines.push(`export ANTHROPIC_BASE_URL=${base}`);
+  }
+  if (tools.includes("codex") || tools.includes("openai-compatible")) {
+    lines.push(`export OPENAI_BASE_URL=${base}/v1`);
   }
+  return lines;
+}
+function lineExistsInFile(filePath, line) {
+  if (!existsSync2(filePath)) return false;
+  try {
+    const content = readFileSync2(filePath, "utf-8");
+    return content.includes(line);
+  } catch {
+    return false;
+  }
+}
+function appendToShellProfile(profile, lines) {
+  const block = [
+    "",
+    "# Liminal \u2014 route AI tools through compression proxy",
+    ...lines
+  ].join("\n") + "\n";
+  appendFileSync(profile.path, block, "utf-8");
 }
 async function initCommand() {
   printBanner();
@@ -383,16 +634,11 @@ async function initCommand() {
   console.log();
   console.log("  Let's start evolving.");
   console.log();
-  const rl = createInterface({ input: stdin, output: stdout });
-  let apiKey;
+  const apiKey = await runAuthFlow();
+  console.log();
+  const rl = createInterface2({ input: stdin2, output: stdout2 });
   let port;
   try {
-    const apiKeyInput = await rl.question("  \x1B[1mLiminal API key\x1B[0m: ");
-    if (!apiKeyInput.trim()) {
-      console.error("\n  Error: API key is required.");
-      process.exit(1);
-    }
-    apiKey = apiKeyInput.trim();
     const portInput = await rl.question(`  Proxy port [${DEFAULTS.port}]: `);
     port = portInput.trim() ? parseInt(portInput.trim(), 10) : DEFAULTS.port;
     if (isNaN(port) || port < 1 || port > 65535) {
@@ -406,10 +652,10 @@ async function initCommand() {
   const toolsResult = await multiSelectPrompt({
     message: "Which AI tools will you use with Liminal?",
     options: [
-      { label: "Claude Code", value: "claude-code", description: "export ANTHROPIC_BASE_URL=...", default: true },
-      { label: "Codex", value: "codex", description: "export OPENAI_BASE_URL=..." },
-      { label: "Cursor", value: "cursor", description: "Settings > Models > Base URL" },
-      { label: "Other / OpenAI", value: "openai-compatible", description: "Set base URL manually" }
+      { label: "Claude Code", value: "claude-code", default: true },
+      { label: "Codex", value: "codex" },
+      { label: "Cursor", value: "cursor" },
+      { label: "Other / OpenAI", value: "openai-compatible" }
     ]
   });
   const tools = toolsResult ?? ["claude-code"];
@@ -425,26 +671,6 @@ async function initCommand() {
   const learnFromResponses = learnResult ?? true;
   console.log();
   const apiBaseUrl = DEFAULTS.apiBaseUrl;
-  process.stdout.write("  Validating API key... ");
-  try {
-    const breaker = new CircuitBreaker(3, 1e4);
-    const transport = new RSCTransport({
-      baseUrl: apiBaseUrl,
-      apiKey,
-      timeout: 1e4,
-      maxRetries: 1,
-      circuitBreaker: breaker
-    });
-    await transport.get("/health");
-    console.log("OK");
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    console.log("FAILED");
-    console.error(`
-  Could not connect to Liminal API: ${message}`);
-    console.error("  Check your API key and URL, then try again.");
-    process.exit(1);
-  }
   ensureDirectories();
   saveConfig({
     apiKey,
@@ -462,22 +688,81 @@ async function initCommand() {
   console.log();
   console.log(`  Configuration saved to ${CONFIG_FILE}`);
   console.log();
-  console.log("  Next steps:");
-  console.log("    1. Start the proxy:  liminal start");
-  console.log("    2. Connect your tools:");
+  const exportLines = getExportLines(tools, port);
+  const hasCursor = tools.includes("cursor");
+  if (exportLines.length > 0) {
+    const profile = detectShellProfile();
+    if (profile) {
+      const allExist = exportLines.every((line) => lineExistsInFile(profile.path, line));
+      if (allExist) {
+        console.log(`  Shell already configured in ${profile.name}`);
+      } else {
+        const autoResult = await selectPrompt({
+          message: "Configure shell automatically?",
+          options: [
+            { label: "Yes", value: true, description: `Add to ${profile.name}` },
+            { label: "No", value: false, description: "I'll set it up manually" }
+          ],
+          defaultIndex: 0
+        });
+        if (autoResult === true) {
+          const newLines = exportLines.filter((line) => !lineExistsInFile(profile.path, line));
+          if (newLines.length > 0) {
+            appendToShellProfile(profile, newLines);
+          }
+          console.log();
+          console.log(`  Added to ${profile.name}:`);
+          for (const line of exportLines) {
+            console.log(`    ${line}`);
+          }
+          console.log();
+          console.log(`  Run \x1B[1msource ${profile.name}\x1B[0m or restart your terminal to apply.`);
+        } else {
+          console.log();
+          console.log("  Add these to your shell profile:");
+          console.log();
+          for (const line of exportLines) {
+            console.log(`    ${line}`);
+          }
+        }
+      }
+    } else {
+      console.log("  Add these to your shell profile:");
+      console.log();
+      for (const line of exportLines) {
+        console.log(`    ${line}`);
+      }
+    }
+  }
+  if (hasCursor) {
+    console.log();
+    console.log("  Cursor setup (manual):");
+    console.log(`    Settings > Models > OpenAI API Base URL: http://127.0.0.1:${port}/v1`);
+  }
+  console.log();
+  console.log("  Next step:");
+  console.log("    liminal start");
   console.log();
-  for (const tool of tools) {
-    printToolInstructions(tool, port);
+}
+
+// src/commands/logout.ts
+async function logoutCommand() {
+  if (!isConfigured()) {
+    console.log("  Not currently logged in.");
+    return;
   }
+  saveConfig({ apiKey: "" });
+  console.log("  Logged out.");
+  console.log("  Run \x1B[1mliminal login\x1B[0m to reconnect.");
 }
 
 // src/rsc/pipeline.ts
 import {
   CompressionPipeline,
-  RSCTransport as RSCTransport2,
+  RSCTransport,
   RSCEventEmitter,
   Session,
-  CircuitBreaker as CircuitBreaker2
+  CircuitBreaker
 } from "@cognisos/rsc-sdk";
 var RSCPipelineWrapper = class {
   pipeline;
@@ -486,8 +771,8 @@ var RSCPipelineWrapper = class {
   transport;
   circuitBreaker;
   constructor(config) {
-    this.circuitBreaker = new CircuitBreaker2(5, 5 * 60 * 1e3);
-    this.transport = new RSCTransport2({
+    this.circuitBreaker = new CircuitBreaker(5, 5 * 60 * 1e3);
+    this.transport = new RSCTransport({
       baseUrl: config.rscBaseUrl,
       apiKey: config.rscApiKey,
       timeout: 3e4,
@@ -1131,7 +1416,7 @@ var ProxyServer = class {
 };
 
 // src/daemon/logger.ts
-import { appendFileSync, statSync, renameSync, mkdirSync as mkdirSync2, existsSync as existsSync2 } from "fs";
+import { appendFileSync as appendFileSync2, statSync, renameSync, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
 import { dirname as dirname2 } from "path";
 var MAX_LOG_SIZE = 10 * 1024 * 1024;
 var MAX_BACKUPS = 2;
@@ -1142,7 +1427,7 @@ var FileLogger = class {
     this.logFile = options?.logFile ?? LOG_FILE;
     this.mirrorStdout = options?.mirrorStdout ?? false;
     const logDir = dirname2(this.logFile);
-    if (!existsSync2(logDir)) {
+    if (!existsSync3(logDir)) {
       mkdirSync2(logDir, { recursive: true });
     }
   }
@@ -1151,7 +1436,7 @@ var FileLogger = class {
     const line = `[${timestamp}] ${message}
 `;
     try {
-      appendFileSync(this.logFile, line);
+      appendFileSync2(this.logFile, line);
     } catch {
       process.stderr.write(`[LOG-WRITE-FAILED] ${line}`);
     }
@@ -1167,7 +1452,7 @@ var FileLogger = class {
       for (let i = MAX_BACKUPS - 1; i >= 1; i--) {
         const from = `${this.logFile}.${i}`;
         const to = `${this.logFile}.${i + 1}`;
-        if (existsSync2(from)) renameSync(from, to);
+        if (existsSync3(from)) renameSync(from, to);
       }
       renameSync(this.logFile, `${this.logFile}.1`);
     } catch {
@@ -1179,16 +1464,16 @@ var FileLogger = class {
 };
 
 // src/daemon/lifecycle.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, unlinkSync, existsSync as existsSync4 } from "fs";
 import { fork } from "child_process";
 import { fileURLToPath } from "url";
 function writePidFile(pid) {
   writeFileSync2(PID_FILE, String(pid), "utf-8");
 }
 function readPidFile() {
-  if (!existsSync3(PID_FILE)) return null;
+  if (!existsSync4(PID_FILE)) return null;
   try {
-    const content = readFileSync2(PID_FILE, "utf-8").trim();
+    const content = readFileSync3(PID_FILE, "utf-8").trim();
     const pid = parseInt(content, 10);
     return isNaN(pid) ? null : pid;
   } catch {
@@ -1197,7 +1482,7 @@ function readPidFile() {
 }
 function removePidFile() {
   try {
-    if (existsSync3(PID_FILE)) unlinkSync(PID_FILE);
+    if (existsSync4(PID_FILE)) unlinkSync(PID_FILE);
   } catch {
   }
 }
@@ -1578,17 +1863,17 @@ async function configCommand(flags) {
 }
 
 // src/commands/logs.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4, statSync as statSync2, createReadStream } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync5, statSync as statSync2, createReadStream } from "fs";
 import { watchFile, unwatchFile } from "fs";
 async function logsCommand(flags) {
   const follow = flags.has("follow") || flags.has("f");
   const linesFlag = flags.get("lines") ?? flags.get("n");
   const lines = typeof linesFlag === "string" ? parseInt(linesFlag, 10) : 50;
-  if (!existsSync4(LOG_FILE)) {
+  if (!existsSync5(LOG_FILE)) {
     console.log('No log file found. Start the daemon with "liminal start" to generate logs.');
     return;
   }
-  const content = readFileSync3(LOG_FILE, "utf-8");
+  const content = readFileSync4(LOG_FILE, "utf-8");
   const allLines = content.split("\n");
   const tail = allLines.slice(-lines - 1);
   process.stdout.write(tail.join("\n"));
@@ -1618,7 +1903,9 @@ var USAGE = `
   liminal v${VERSION} \u2014 Transparent LLM context compression proxy
 
   Usage:
-    liminal init                          Set up Liminal (API key, config)
+    liminal init                          Set up Liminal (login, config)
+    liminal login                         Log in or create an account
+    liminal logout                        Log out of your account
     liminal start [-d] [--port PORT]      Start the compression proxy
     liminal stop                          Stop the running proxy
     liminal status                        Show proxy health and stats
@@ -1631,7 +1918,7 @@ var USAGE = `
     -v, --version    Show version number
 
   Getting started:
-    1. liminal init                          # Enter your API key + select tools
+    1. liminal init                          # Log in + select tools
     2. liminal start                         # Start the proxy
     3. Connect your AI tools:
        Claude Code:   export ANTHROPIC_BASE_URL=http://localhost:3141
@@ -1678,6 +1965,12 @@ async function main() {
       case "init":
         await initCommand();
         break;
+      case "login":
+        await loginCommand();
+        break;
+      case "logout":
+        await logoutCommand();
+        break;
       case "start":
         await startCommand(flags);
         break;