@keepgoingdev/cli 0.2.1 → 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,82 +218,214 @@ 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";
 var REQUEST_TIMEOUT_MS = 15e3;
@@ -334,13 +476,21 @@ async function activateLicense(licenseKey, instanceName, options) {
         }
         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) {
     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";
@@ -483,7 +633,7 @@ import { spawn } from "child_process";
 import { readFileSync, existsSync } from "fs";
 import path6 from "path";
 import os2 from "os";
-var CLI_VERSION = "0.2.1";
+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;
@@ -759,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...");
@@ -771,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
@@ -874,13 +1065,13 @@ async function main() {
       }
       break;
     case "version":
-      console.log(`keepgoing v${"0.2.1"}`);
+      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.1",
+  "version": "0.3.0",
   "description": "Terminal CLI for KeepGoing. Resume side projects without the mental friction.",
   "type": "module",
   "main": "./dist/index.js",