@keepgoingdev/cli 0.2.0 → 0.3.0

package/dist/index.js

@@ -57,14 +57,12 @@ import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 function findGitRoot(startPath) {
   try {
-    const gitCommonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+    const toplevel = execFileSync("git", ["rev-parse", "--show-toplevel"], {
       cwd: startPath,
       encoding: "utf-8",
       timeout: 5e3
     }).trim();
-    if (!gitCommonDir) return startPath;
-    const absoluteGitDir = path.isAbsolute(gitCommonDir) ? gitCommonDir : path.resolve(startPath, gitCommonDir);
-    return path.dirname(absoluteGitDir);
+    return toplevel || startPath;
   } catch {
     return startPath;
   }
@@ -132,22 +130,34 @@ function getRecentSessions(allSessions, count = RECENT_SESSION_COUNT) {
 // ../../packages/shared/src/storage.ts
 import fs from "fs";
 import path2 from "path";
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID2, createHash } from "crypto";
 var STORAGE_DIR = ".keepgoing";
 var META_FILE = "meta.json";
 var SESSIONS_FILE = "sessions.json";
 var STATE_FILE = "state.json";
+var CURRENT_TASKS_FILE = "current-tasks.json";
+var STALE_SESSION_MS = 2 * 60 * 60 * 1e3;
+function pruneStaleTasks(tasks) {
+  const now = Date.now();
+  return tasks.filter((t) => {
+    if (t.sessionActive) return true;
+    const updatedAt = new Date(t.updatedAt).getTime();
+    return !isNaN(updatedAt) && now - updatedAt < STALE_SESSION_MS;
+  });
+}
 var KeepGoingWriter = class {
   storagePath;
   sessionsFilePath;
   stateFilePath;
   metaFilePath;
+  currentTasksFilePath;
   constructor(workspacePath) {
     const mainRoot = resolveStorageRoot(workspacePath);
     this.storagePath = path2.join(mainRoot, STORAGE_DIR);
     this.sessionsFilePath = path2.join(this.storagePath, SESSIONS_FILE);
     this.stateFilePath = path2.join(this.storagePath, STATE_FILE);
     this.metaFilePath = path2.join(this.storagePath, META_FILE);
+    this.currentTasksFilePath = path2.join(this.storagePath, CURRENT_TASKS_FILE);
   }
   ensureDir() {
     if (!fs.existsSync(this.storagePath)) {
@@ -208,120 +218,300 @@ var KeepGoingWriter = class {
     }
     fs.writeFileSync(this.metaFilePath, JSON.stringify(meta, null, 2), "utf-8");
   }
+  // ---------------------------------------------------------------------------
+  // Multi-session API
+  // ---------------------------------------------------------------------------
+  /** Read all current tasks from current-tasks.json. Auto-prunes stale sessions. */
+  readCurrentTasks() {
+    try {
+      if (fs.existsSync(this.currentTasksFilePath)) {
+        const raw = JSON.parse(fs.readFileSync(this.currentTasksFilePath, "utf-8"));
+        const tasks = Array.isArray(raw) ? raw : raw.tasks ?? [];
+        return this.pruneStale(tasks);
+      }
+    } catch {
+    }
+    return [];
+  }
+  /**
+   * Upsert a session task by sessionId into current-tasks.json.
+   * If no sessionId is present on the task, generates one.
+   */
+  upsertSession(update) {
+    this.ensureDir();
+    this.upsertSessionCore(update);
+  }
+  /** Core upsert logic: merges the update into current-tasks.json and returns the pruned task list. */
+  upsertSessionCore(update) {
+    this.ensureDir();
+    const sessionId = update.sessionId || generateSessionId(update);
+    const tasks = this.readAllTasksRaw();
+    const existingIdx = tasks.findIndex((t) => t.sessionId === sessionId);
+    let merged;
+    if (existingIdx >= 0) {
+      const existing = tasks[existingIdx];
+      merged = { ...existing, ...update, sessionId };
+      tasks[existingIdx] = merged;
+    } else {
+      merged = { ...update, sessionId };
+      tasks.push(merged);
+    }
+    const pruned = this.pruneStale(tasks);
+    this.writeTasksFile(pruned);
+    return pruned;
+  }
+  /** Remove a specific session by ID. */
+  removeSession(sessionId) {
+    const tasks = this.readAllTasksRaw().filter((t) => t.sessionId !== sessionId);
+    this.writeTasksFile(tasks);
+  }
+  /** Get all active sessions (sessionActive=true and within stale threshold). */
+  getActiveSessions() {
+    return this.readCurrentTasks().filter((t) => t.sessionActive);
+  }
+  /** Get a specific session by ID. */
+  getSession(sessionId) {
+    return this.readCurrentTasks().find((t) => t.sessionId === sessionId);
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  readAllTasksRaw() {
+    try {
+      if (fs.existsSync(this.currentTasksFilePath)) {
+        const raw = JSON.parse(fs.readFileSync(this.currentTasksFilePath, "utf-8"));
+        return Array.isArray(raw) ? [...raw] : [...raw.tasks ?? []];
+      }
+    } catch {
+    }
+    return [];
+  }
+  pruneStale(tasks) {
+    return pruneStaleTasks(tasks);
+  }
+  writeTasksFile(tasks) {
+    const data = { version: 1, tasks };
+    fs.writeFileSync(this.currentTasksFilePath, JSON.stringify(data, null, 2), "utf-8");
+  }
 };
+function generateSessionId(context) {
+  const parts = [
+    context.worktreePath || context.workspaceRoot || "",
+    context.agentLabel || "",
+    context.branch || ""
+  ].filter(Boolean);
+  if (parts.length === 0) {
+    return randomUUID2();
+  }
+  const hash = createHash("sha256").update(parts.join("|")).digest("hex").slice(0, 12);
+  return `ses_${hash}`;
+}
 
 // ../../packages/shared/src/decisionStorage.ts
-import fs2 from "fs";
-import path3 from "path";
-
-// ../../packages/shared/src/featureGate.ts
-var DefaultFeatureGate = class {
-  isEnabled(_feature) {
-    return true;
-  }
-};
-var currentGate = new DefaultFeatureGate();
+import fs3 from "fs";
+import path4 from "path";
 
 // ../../packages/shared/src/license.ts
 import crypto from "crypto";
-import fs3 from "fs";
+import fs2 from "fs";
 import os from "os";
-import path4 from "path";
+import path3 from "path";
 var LICENSE_FILE = "license.json";
 var DEVICE_ID_FILE = "device-id";
 function getGlobalLicenseDir() {
-  return path4.join(os.homedir(), ".keepgoing");
+  return path3.join(os.homedir(), ".keepgoing");
 }
 function getGlobalLicensePath() {
-  return path4.join(getGlobalLicenseDir(), LICENSE_FILE);
+  return path3.join(getGlobalLicenseDir(), LICENSE_FILE);
 }
 function getDeviceId() {
   const dir = getGlobalLicenseDir();
-  const filePath = path4.join(dir, DEVICE_ID_FILE);
+  const filePath = path3.join(dir, DEVICE_ID_FILE);
   try {
-    const existing = fs3.readFileSync(filePath, "utf-8").trim();
+    const existing = fs2.readFileSync(filePath, "utf-8").trim();
     if (existing) return existing;
   } catch {
   }
   const id = crypto.randomUUID();
-  if (!fs3.existsSync(dir)) {
-    fs3.mkdirSync(dir, { recursive: true });
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
   }
-  fs3.writeFileSync(filePath, id, "utf-8");
+  fs2.writeFileSync(filePath, id, "utf-8");
   return id;
 }
-function readLicenseCache() {
+var DECISION_DETECTION_VARIANT_ID = 1361527;
+var SESSION_AWARENESS_VARIANT_ID = 1366510;
+var TEST_DECISION_DETECTION_VARIANT_ID = 1345647;
+var TEST_SESSION_AWARENESS_VARIANT_ID = 1365992;
+var VARIANT_FEATURE_MAP = {
+  [DECISION_DETECTION_VARIANT_ID]: ["decisions"],
+  [SESSION_AWARENESS_VARIANT_ID]: ["session-awareness"],
+  [TEST_DECISION_DETECTION_VARIANT_ID]: ["decisions"],
+  [TEST_SESSION_AWARENESS_VARIANT_ID]: ["session-awareness"]
+  // Future bundle: [BUNDLE_VARIANT_ID]: ['decisions', 'session-awareness'],
+};
+var KNOWN_VARIANT_IDS = new Set(Object.keys(VARIANT_FEATURE_MAP).map(Number));
+function getVariantLabel(variantId) {
+  const features = VARIANT_FEATURE_MAP[variantId];
+  if (!features) return "Unknown Add-on";
+  if (features.includes("decisions") && features.includes("session-awareness")) return "Pro Bundle";
+  if (features.includes("decisions")) return "Decision Detection";
+  if (features.includes("session-awareness")) return "Session Awareness";
+  return "Pro Add-on";
+}
+var _cachedStore;
+var _cacheTimestamp = 0;
+var LICENSE_CACHE_TTL_MS = 2e3;
+function readLicenseStore() {
+  const now = Date.now();
+  if (_cachedStore && now - _cacheTimestamp < LICENSE_CACHE_TTL_MS) {
+    return _cachedStore;
+  }
   const licensePath = getGlobalLicensePath();
+  let store;
   try {
-    if (!fs3.existsSync(licensePath)) {
-      return void 0;
+    if (!fs2.existsSync(licensePath)) {
+      store = { version: 2, licenses: [] };
+    } else {
+      const raw = fs2.readFileSync(licensePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data?.version === 2 && Array.isArray(data.licenses)) {
+        store = data;
+      } else {
+        store = { version: 2, licenses: [] };
+      }
     }
-    const raw = fs3.readFileSync(licensePath, "utf-8");
-    return JSON.parse(raw);
   } catch {
-    return void 0;
+    store = { version: 2, licenses: [] };
   }
+  _cachedStore = store;
+  _cacheTimestamp = now;
+  return store;
 }
-function writeLicenseCache(cache) {
+function writeLicenseStore(store) {
   const dirPath = getGlobalLicenseDir();
-  if (!fs3.existsSync(dirPath)) {
-    fs3.mkdirSync(dirPath, { recursive: true });
+  if (!fs2.existsSync(dirPath)) {
+    fs2.mkdirSync(dirPath, { recursive: true });
   }
-  const licensePath = path4.join(dirPath, LICENSE_FILE);
-  fs3.writeFileSync(licensePath, JSON.stringify(cache, null, 2), "utf-8");
+  const licensePath = path3.join(dirPath, LICENSE_FILE);
+  fs2.writeFileSync(licensePath, JSON.stringify(store, null, 2), "utf-8");
+  _cachedStore = store;
+  _cacheTimestamp = Date.now();
 }
-function deleteLicenseCache() {
-  const licensePath = getGlobalLicensePath();
-  try {
-    if (fs3.existsSync(licensePath)) {
-      fs3.unlinkSync(licensePath);
-    }
-  } catch {
+function addLicenseEntry(entry) {
+  const store = readLicenseStore();
+  const idx = store.licenses.findIndex((l) => l.licenseKey === entry.licenseKey);
+  if (idx >= 0) {
+    store.licenses[idx] = entry;
+  } else {
+    store.licenses.push(entry);
   }
+  writeLicenseStore(store);
 }
-function isCachedLicenseValid(cache) {
-  return cache?.status === "active";
+function removeLicenseEntry(licenseKey) {
+  const store = readLicenseStore();
+  store.licenses = store.licenses.filter((l) => l.licenseKey !== licenseKey);
+  writeLicenseStore(store);
+}
+function getActiveLicenses() {
+  return readLicenseStore().licenses.filter((l) => l.status === "active");
 }
 var REVALIDATION_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
 
+// ../../packages/shared/src/featureGate.ts
+var DefaultFeatureGate = class {
+  isEnabled(_feature) {
+    return true;
+  }
+};
+var currentGate = new DefaultFeatureGate();
+
 // ../../packages/shared/src/licenseClient.ts
 var BASE_URL = "https://api.lemonsqueezy.com/v1/licenses";
-async function activateLicense(licenseKey, instanceName) {
+var REQUEST_TIMEOUT_MS = 15e3;
+var EXPECTED_STORE_ID = 301555;
+var EXPECTED_PRODUCT_ID = 864311;
+function fetchWithTimeout(url, init) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  return fetch(url, { ...init, signal: controller.signal }).finally(() => clearTimeout(timer));
+}
+function validateProductIdentity(meta) {
+  if (!meta) return "License response missing product metadata.";
+  if (meta.store_id !== EXPECTED_STORE_ID || meta.product_id !== EXPECTED_PRODUCT_ID) {
+    return "This license key does not belong to KeepGoing.";
+  }
+  return void 0;
+}
+async function safeJson(res) {
   try {
-    const res = await fetch(`${BASE_URL}/activate`, {
+    const text = await res.text();
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+async function activateLicense(licenseKey, instanceName, options) {
+  try {
+    const res = await fetchWithTimeout(`${BASE_URL}/activate`, {
       method: "POST",
       headers: { "Content-Type": "application/x-www-form-urlencoded" },
       body: new URLSearchParams({ license_key: licenseKey, instance_name: instanceName })
     });
-    const data = await res.json();
-    if (!res.ok || !data.activated) {
-      return { valid: false, error: data.error || `Activation failed (${res.status})` };
+    const data = await safeJson(res);
+    if (!res.ok || !data?.activated) {
+      return { valid: false, error: data?.error || `Activation failed (${res.status})` };
+    }
+    if (!options?.allowTestMode && data.license_key?.test_mode) {
+      if (data.license_key?.key && data.instance?.id) {
+        await deactivateLicense(data.license_key.key, data.instance.id);
+      }
+      return { valid: false, error: "This is a test license key. Please use a production license key from your purchase confirmation." };
+    }
+    if (!options?.allowTestMode) {
+      const productError = validateProductIdentity(data.meta);
+      if (productError) {
+        if (data.license_key?.key && data.instance?.id) {
+          await deactivateLicense(data.license_key.key, data.instance.id);
+        }
+        return { valid: false, error: productError };
+      }
+      if (data.meta?.variant_id && !KNOWN_VARIANT_IDS.has(data.meta.variant_id)) {
+        if (data.license_key?.key && data.instance?.id) {
+          await deactivateLicense(data.license_key.key, data.instance.id);
+        }
+        return { valid: false, error: "This license key is for an unrecognized add-on variant. Please update KeepGoing or contact support." };
+      }
     }
     return {
       valid: true,
       licenseKey: data.license_key?.key,
       instanceId: data.instance?.id,
       customerName: data.meta?.customer_name,
-      productName: data.meta?.product_name
+      productName: data.meta?.product_name,
+      variantId: data.meta?.variant_id,
+      variantName: data.meta?.variant_name
     };
   } catch (err) {
-    return { valid: false, error: err instanceof Error ? err.message : "Network error" };
+    const message = err instanceof Error && err.name === "AbortError" ? "Request timed out. Please check your network connection and try again." : err instanceof Error ? err.message : "Network error";
+    return { valid: false, error: message };
   }
 }
 async function deactivateLicense(licenseKey, instanceId) {
   try {
-    const res = await fetch(`${BASE_URL}/deactivate`, {
+    const res = await fetchWithTimeout(`${BASE_URL}/deactivate`, {
       method: "POST",
       headers: { "Content-Type": "application/x-www-form-urlencoded" },
       body: new URLSearchParams({ license_key: licenseKey, instance_id: instanceId })
     });
-    const data = await res.json();
-    if (!res.ok || !data.deactivated) {
-      return { deactivated: false, error: data.error || `Deactivation failed (${res.status})` };
+    const data = await safeJson(res);
+    if (!res.ok || !data?.deactivated) {
+      return { deactivated: false, error: data?.error || `Deactivation failed (${res.status})` };
     }
     return { deactivated: true };
   } catch (err) {
-    return { deactivated: false, error: err instanceof Error ? err.message : "Network error" };
+    const message = err instanceof Error && err.name === "AbortError" ? "Request timed out. Please check your network connection and try again." : err instanceof Error ? err.message : "Network error";
+    return { deactivated: false, error: message };
   }
 }
 
@@ -438,7 +628,96 @@ function renderNoData() {
   );
 }
 
+// src/updateCheck.ts
+import { spawn } from "child_process";
+import { readFileSync, existsSync } from "fs";
+import path6 from "path";
+import os2 from "os";
+var CLI_VERSION = "0.3.0";
+var NPM_REGISTRY_URL = "https://registry.npmjs.org/@keepgoingdev/cli/latest";
+var FETCH_TIMEOUT_MS = 5e3;
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var CACHE_DIR = path6.join(os2.homedir(), ".keepgoing");
+var CACHE_PATH = path6.join(CACHE_DIR, "update-check.json");
+function isNewerVersion(current, latest) {
+  const cur = current.split(".").map(Number);
+  const lat = latest.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((lat[i] ?? 0) > (cur[i] ?? 0)) return true;
+    if ((lat[i] ?? 0) < (cur[i] ?? 0)) return false;
+  }
+  return false;
+}
+function getCachedUpdateInfo() {
+  try {
+    if (!existsSync(CACHE_PATH)) return null;
+    const raw = readFileSync(CACHE_PATH, "utf-8");
+    const cache = JSON.parse(raw);
+    if (!cache.latest || !cache.checkedAt) return null;
+    const age = Date.now() - new Date(cache.checkedAt).getTime();
+    if (age > CHECK_INTERVAL_MS) return null;
+    return {
+      current: CLI_VERSION,
+      latest: cache.latest,
+      updateAvailable: isNewerVersion(CLI_VERSION, cache.latest)
+    };
+  } catch {
+    return null;
+  }
+}
+function spawnBackgroundCheck() {
+  try {
+    if (existsSync(CACHE_PATH)) {
+      const raw = readFileSync(CACHE_PATH, "utf-8");
+      const cache = JSON.parse(raw);
+      const age = Date.now() - new Date(cache.checkedAt).getTime();
+      if (age < CHECK_INTERVAL_MS) return;
+    }
+  } catch {
+  }
+  const script = `
+    const https = require('https');
+    const fs = require('fs');
+    const path = require('path');
+    const os = require('os');
+
+    const url = ${JSON.stringify(NPM_REGISTRY_URL)};
+    const cacheDir = path.join(os.homedir(), '.keepgoing');
+    const cachePath = path.join(cacheDir, 'update-check.json');
+    const currentVersion = ${JSON.stringify(CLI_VERSION)};
+
+    const req = https.get(url, { timeout: ${FETCH_TIMEOUT_MS} }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        try {
+          const latest = JSON.parse(data).version;
+          if (!latest) process.exit(0);
+          if (!fs.existsSync(cacheDir)) fs.mkdirSync(cacheDir, { recursive: true });
+          fs.writeFileSync(cachePath, JSON.stringify({
+            latest,
+            current: currentVersion,
+            checkedAt: new Date().toISOString(),
+          }));
+        } catch {}
+        process.exit(0);
+      });
+    });
+    req.on('error', () => process.exit(0));
+    req.on('timeout', () => { req.destroy(); process.exit(0); });
+  `;
+  const child = spawn(process.execPath, ["-e", script], {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env }
+  });
+  child.unref();
+}
+
 // src/commands/status.ts
+var RESET2 = "\x1B[0m";
+var BOLD2 = "\x1B[1m";
+var DIM2 = "\x1B[2m";
 async function statusCommand(opts) {
   const reader = new KeepGoingReader(opts.cwd);
   if (!reader.exists()) {
@@ -466,11 +745,16 @@ async function statusCommand(opts) {
     (Date.now() - new Date(lastSession.timestamp).getTime()) / (1e3 * 60 * 60 * 24)
   );
   renderCheckpoint(lastSession, daysSince);
+  const cached = getCachedUpdateInfo();
+  if (cached?.updateAvailable) {
+    console.log(`${DIM2}Update available: ${cached.current} \u2192 ${cached.latest}. Run: ${RESET2}${BOLD2}npm install -g @keepgoingdev/cli@latest${RESET2}`);
+  }
+  spawnBackgroundCheck();
 }
 
 // src/commands/save.ts
 import readline from "readline";
-import path6 from "path";
+import path7 from "path";
 function prompt(rl, question) {
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
@@ -514,7 +798,7 @@ async function saveCommand(opts) {
     workspaceRoot: opts.cwd,
     source: "manual"
   });
-  const projectName = path6.basename(opts.cwd);
+  const projectName = path7.basename(opts.cwd);
   const writer = new KeepGoingWriter(opts.cwd);
   writer.saveCheckpoint(checkpoint, projectName);
   console.log("Checkpoint saved.");
@@ -522,8 +806,8 @@ async function saveCommand(opts) {
 
 // src/commands/hook.ts
 import fs5 from "fs";
-import path7 from "path";
-import os2 from "os";
+import path8 from "path";
+import os3 from "os";
 var HOOK_MARKER_START = "# keepgoing-hook-start";
 var HOOK_MARKER_END = "# keepgoing-hook-end";
 var ZSH_HOOK = `${HOOK_MARKER_START}
@@ -549,12 +833,12 @@ fi
 ${HOOK_MARKER_END}`;
 function detectShellRcFile() {
   const shellEnv = process.env["SHELL"] ?? "";
-  const home = os2.homedir();
+  const home = os3.homedir();
   if (shellEnv.endsWith("zsh")) {
-    return { shell: "zsh", rcFile: path7.join(home, ".zshrc") };
+    return { shell: "zsh", rcFile: path8.join(home, ".zshrc") };
   }
   if (shellEnv.endsWith("bash")) {
-    return { shell: "bash", rcFile: path7.join(home, ".bashrc") };
+    return { shell: "bash", rcFile: path8.join(home, ".bashrc") };
   }
   return void 0;
 }
@@ -625,10 +909,14 @@ async function activateCommand({ licenseKey }) {
     console.error("Usage: keepgoing activate <license-key>");
     process.exit(1);
   }
-  const existing = readLicenseCache();
-  if (isCachedLicenseValid(existing)) {
-    const who2 = existing.customerName ? ` (${existing.customerName})` : "";
-    console.log(`Pro license is already active${who2}.`);
+  const store = readLicenseStore();
+  const existingForKey = store.licenses.find(
+    (l) => l.status === "active" && l.licenseKey === licenseKey
+  );
+  if (existingForKey) {
+    const label2 = getVariantLabel(existingForKey.variantId);
+    const who2 = existingForKey.customerName ? ` (${existingForKey.customerName})` : "";
+    console.log(`${label2} is already active${who2}.`);
     return;
   }
   console.log("Activating license...");
@@ -637,35 +925,72 @@ async function activateCommand({ licenseKey }) {
     console.error(`Activation failed: ${result.error ?? "unknown error"}`);
     process.exit(1);
   }
+  const variantId = result.variantId;
+  const existingForVariant = store.licenses.find(
+    (l) => l.status === "active" && l.variantId === variantId
+  );
+  if (existingForVariant) {
+    const label2 = getVariantLabel(variantId);
+    const who2 = existingForVariant.customerName ? ` (${existingForVariant.customerName})` : "";
+    console.log(`${label2} is already active${who2}.`);
+    return;
+  }
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  writeLicenseCache({
+  addLicenseEntry({
     licenseKey: result.licenseKey || licenseKey,
     instanceId: result.instanceId || getDeviceId(),
     status: "active",
     lastValidatedAt: now,
     activatedAt: now,
+    variantId,
     customerName: result.customerName,
-    productName: result.productName
+    productName: result.productName,
+    variantName: result.variantName
   });
+  const label = getVariantLabel(variantId);
   const who = result.customerName ? ` Welcome, ${result.customerName}!` : "";
-  console.log(`Pro license activated successfully.${who}`);
+  console.log(`${label} activated successfully.${who}`);
 }
 
 // src/commands/deactivate.ts
-async function deactivateCommand() {
-  const cache = readLicenseCache();
-  if (!cache) {
+async function deactivateCommand(opts) {
+  const active = getActiveLicenses();
+  if (active.length === 0) {
     console.log("No active license found on this device.");
     return;
   }
+  let targets;
+  if (opts?.licenseKey) {
+    const match = active.find((l) => l.licenseKey === opts.licenseKey);
+    if (!match) {
+      console.error(`No active license found with key "${opts.licenseKey}".`);
+      process.exit(1);
+    }
+    targets = [match];
+  } else if (active.length === 1) {
+    targets = active;
+  } else {
+    console.log("Multiple active licenses found. Specify which to deactivate:");
+    console.log("  keepgoing deactivate <license-key>");
+    console.log("");
+    for (const l of active) {
+      const label = getVariantLabel(l.variantId);
+      const who = l.customerName ? ` (${l.customerName})` : "";
+      console.log(`  ${label}${who}: ${l.licenseKey}`);
+    }
+    return;
+  }
   console.log("Deactivating license...");
-  const result = await deactivateLicense(cache.licenseKey, cache.instanceId);
-  deleteLicenseCache();
-  if (!result.deactivated) {
-    console.error(`License cleared locally, but remote deactivation failed: ${result.error ?? "unknown error"}`);
-    process.exit(1);
+  for (const entry of targets) {
+    const result = await deactivateLicense(entry.licenseKey, entry.instanceId);
+    removeLicenseEntry(entry.licenseKey);
+    const label = getVariantLabel(entry.variantId);
+    if (!result.deactivated) {
+      console.error(`${label} license cleared locally, but remote deactivation failed: ${result.error ?? "unknown error"}`);
+    } else {
+      console.log(`${label} license deactivated successfully. The activation slot has been freed.`);
+    }
   }
-  console.log("Pro license deactivated successfully. The activation slot has been freed.");
 }
 
 // src/index.ts
@@ -683,6 +1008,7 @@ Options:
   --cwd <path>    Override the working directory (default: current directory)
   --json          Output raw JSON (status only)
   --quiet         Output a single summary line (status only)
+  -v, --version   Show the CLI version
   -h, --help      Show this help text
 
 Hook subcommands:
@@ -704,6 +1030,8 @@ function parseArgs(argv) {
       json = true;
     } else if (arg === "--quiet") {
       quiet = true;
+    } else if (arg === "-v" || arg === "--version") {
+      command = "version";
     } else if (arg === "-h" || arg === "--help") {
       command = "help";
     } else if (!command) {
@@ -736,11 +1064,14 @@ async function main() {
         process.exit(1);
       }
       break;
+    case "version":
+      console.log(`keepgoing v${"0.3.0"}`);
+      break;
     case "activate":
       await activateCommand({ licenseKey: subcommand });
       break;
     case "deactivate":
-      await deactivateCommand();
+      await deactivateCommand({ licenseKey: subcommand || void 0 });
       break;
     case "help":
     case "":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keepgoingdev/cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Terminal CLI for KeepGoing. Resume side projects without the mental friction.",
   "type": "module",
   "main": "./dist/index.js",