@keepgoingdev/cli 0.1.1 → 0.2.1

package/dist/index.js

@@ -52,17 +52,46 @@ function formatRelativeTime(timestamp) {
 
 // ../../packages/shared/src/gitUtils.ts
 import { execFileSync, execFile } from "child_process";
+import path from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 function findGitRoot(startPath) {
   try {
-    const result = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+    const gitCommonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
       cwd: startPath,
       encoding: "utf-8",
       timeout: 5e3
-    });
-    return result.trim() || startPath;
+    }).trim();
+    if (!gitCommonDir) return startPath;
+    const absoluteGitDir = path.isAbsolute(gitCommonDir) ? gitCommonDir : path.resolve(startPath, gitCommonDir);
+    return path.dirname(absoluteGitDir);
+  } catch {
+    return startPath;
+  }
+}
+var storageRootCache = /* @__PURE__ */ new Map();
+function resolveStorageRoot(startPath) {
+  const cached = storageRootCache.get(startPath);
+  if (cached !== void 0) {
+    return cached;
+  }
+  try {
+    const toplevel = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+      cwd: startPath,
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+      cwd: startPath,
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    const absoluteCommonDir = path.resolve(toplevel, commonDir);
+    const mainRoot = path.dirname(absoluteCommonDir);
+    storageRootCache.set(startPath, mainRoot);
+    return mainRoot;
   } catch {
+    storageRootCache.set(startPath, startPath);
     return startPath;
   }
 }
@@ -102,7 +131,7 @@ function getRecentSessions(allSessions, count = RECENT_SESSION_COUNT) {
 
 // ../../packages/shared/src/storage.ts
 import fs from "fs";
-import path from "path";
+import path2 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
 var STORAGE_DIR = ".keepgoing";
 var META_FILE = "meta.json";
@@ -114,10 +143,11 @@ var KeepGoingWriter = class {
   stateFilePath;
   metaFilePath;
   constructor(workspacePath) {
-    this.storagePath = path.join(workspacePath, STORAGE_DIR);
-    this.sessionsFilePath = path.join(this.storagePath, SESSIONS_FILE);
-    this.stateFilePath = path.join(this.storagePath, STATE_FILE);
-    this.metaFilePath = path.join(this.storagePath, META_FILE);
+    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);
   }
   ensureDir() {
     if (!fs.existsSync(this.storagePath)) {
@@ -182,7 +212,7 @@ var KeepGoingWriter = class {
 
 // ../../packages/shared/src/decisionStorage.ts
 import fs2 from "fs";
-import path2 from "path";
+import path3 from "path";
 
 // ../../packages/shared/src/featureGate.ts
 var DefaultFeatureGate = class {
@@ -192,9 +222,152 @@ var DefaultFeatureGate = class {
 };
 var currentGate = new DefaultFeatureGate();
 
-// src/storage.ts
+// ../../packages/shared/src/license.ts
+import crypto from "crypto";
 import fs3 from "fs";
-import path3 from "path";
+import os from "os";
+import path4 from "path";
+var LICENSE_FILE = "license.json";
+var DEVICE_ID_FILE = "device-id";
+function getGlobalLicenseDir() {
+  return path4.join(os.homedir(), ".keepgoing");
+}
+function getGlobalLicensePath() {
+  return path4.join(getGlobalLicenseDir(), LICENSE_FILE);
+}
+function getDeviceId() {
+  const dir = getGlobalLicenseDir();
+  const filePath = path4.join(dir, DEVICE_ID_FILE);
+  try {
+    const existing = fs3.readFileSync(filePath, "utf-8").trim();
+    if (existing) return existing;
+  } catch {
+  }
+  const id = crypto.randomUUID();
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  fs3.writeFileSync(filePath, id, "utf-8");
+  return id;
+}
+function readLicenseCache() {
+  const licensePath = getGlobalLicensePath();
+  try {
+    if (!fs3.existsSync(licensePath)) {
+      return void 0;
+    }
+    const raw = fs3.readFileSync(licensePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+function writeLicenseCache(cache) {
+  const dirPath = getGlobalLicenseDir();
+  if (!fs3.existsSync(dirPath)) {
+    fs3.mkdirSync(dirPath, { recursive: true });
+  }
+  const licensePath = path4.join(dirPath, LICENSE_FILE);
+  fs3.writeFileSync(licensePath, JSON.stringify(cache, null, 2), "utf-8");
+}
+function deleteLicenseCache() {
+  const licensePath = getGlobalLicensePath();
+  try {
+    if (fs3.existsSync(licensePath)) {
+      fs3.unlinkSync(licensePath);
+    }
+  } catch {
+  }
+}
+function isCachedLicenseValid(cache) {
+  return cache?.status === "active";
+}
+var REVALIDATION_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+
+// ../../packages/shared/src/licenseClient.ts
+var BASE_URL = "https://api.lemonsqueezy.com/v1/licenses";
+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 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 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 };
+      }
+    }
+    return {
+      valid: true,
+      licenseKey: data.license_key?.key,
+      instanceId: data.instance?.id,
+      customerName: data.meta?.customer_name,
+      productName: data.meta?.product_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";
+    return { valid: false, error: message };
+  }
+}
+async function deactivateLicense(licenseKey, instanceId) {
+  try {
+    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 safeJson(res);
+    if (!res.ok || !data?.deactivated) {
+      return { deactivated: false, error: data?.error || `Deactivation failed (${res.status})` };
+    }
+    return { deactivated: true };
+  } 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";
+    return { deactivated: false, error: message };
+  }
+}
+
+// src/storage.ts
+import fs4 from "fs";
+import path5 from "path";
 var STORAGE_DIR2 = ".keepgoing";
 var META_FILE2 = "meta.json";
 var SESSIONS_FILE2 = "sessions.json";
@@ -205,13 +378,13 @@ var KeepGoingReader = class {
   sessionsFilePath;
   stateFilePath;
   constructor(workspacePath) {
-    this.storagePath = path3.join(workspacePath, STORAGE_DIR2);
-    this.metaFilePath = path3.join(this.storagePath, META_FILE2);
-    this.sessionsFilePath = path3.join(this.storagePath, SESSIONS_FILE2);
-    this.stateFilePath = path3.join(this.storagePath, STATE_FILE2);
+    this.storagePath = path5.join(workspacePath, STORAGE_DIR2);
+    this.metaFilePath = path5.join(this.storagePath, META_FILE2);
+    this.sessionsFilePath = path5.join(this.storagePath, SESSIONS_FILE2);
+    this.stateFilePath = path5.join(this.storagePath, STATE_FILE2);
   }
   exists() {
-    return fs3.existsSync(this.storagePath);
+    return fs4.existsSync(this.storagePath);
   }
   getState() {
     return this.readJsonFile(this.stateFilePath);
@@ -249,8 +422,8 @@ var KeepGoingReader = class {
   }
   readJsonFile(filePath) {
     try {
-      if (!fs3.existsSync(filePath)) return void 0;
-      const raw = fs3.readFileSync(filePath, "utf-8");
+      if (!fs4.existsSync(filePath)) return void 0;
+      const raw = fs4.readFileSync(filePath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -305,7 +478,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.2.1";
+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()) {
@@ -333,11 +595,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 path4 from "path";
+import path7 from "path";
 function prompt(rl, question) {
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
@@ -381,16 +648,16 @@ async function saveCommand(opts) {
     workspaceRoot: opts.cwd,
     source: "manual"
   });
-  const projectName = path4.basename(opts.cwd);
+  const projectName = path7.basename(opts.cwd);
   const writer = new KeepGoingWriter(opts.cwd);
   writer.saveCheckpoint(checkpoint, projectName);
   console.log("Checkpoint saved.");
 }
 
 // src/commands/hook.ts
-import fs4 from "fs";
-import path5 from "path";
-import os from "os";
+import fs5 from "fs";
+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}
@@ -416,12 +683,12 @@ fi
 ${HOOK_MARKER_END}`;
 function detectShellRcFile() {
   const shellEnv = process.env["SHELL"] ?? "";
-  const home = os.homedir();
+  const home = os3.homedir();
   if (shellEnv.endsWith("zsh")) {
-    return { shell: "zsh", rcFile: path5.join(home, ".zshrc") };
+    return { shell: "zsh", rcFile: path8.join(home, ".zshrc") };
   }
   if (shellEnv.endsWith("bash")) {
-    return { shell: "bash", rcFile: path5.join(home, ".bashrc") };
+    return { shell: "bash", rcFile: path8.join(home, ".bashrc") };
   }
   return void 0;
 }
@@ -437,14 +704,14 @@ function hookInstallCommand() {
   const hookBlock = shell === "zsh" ? ZSH_HOOK : BASH_HOOK;
   let existing = "";
   try {
-    existing = fs4.readFileSync(rcFile, "utf-8");
+    existing = fs5.readFileSync(rcFile, "utf-8");
   } catch {
   }
   if (existing.includes(HOOK_MARKER_START)) {
     console.log(`KeepGoing hook is already installed in ${rcFile}.`);
     return;
   }
-  fs4.appendFileSync(rcFile, `
+  fs5.appendFileSync(rcFile, `
 ${hookBlock}
 `, "utf-8");
   console.log(`KeepGoing hook installed in ${rcFile}.`);
@@ -463,7 +730,7 @@ function hookUninstallCommand() {
   const { rcFile } = detected;
   let existing = "";
   try {
-    existing = fs4.readFileSync(rcFile, "utf-8");
+    existing = fs5.readFileSync(rcFile, "utf-8");
   } catch {
     console.log(`${rcFile} not found \u2014 nothing to remove.`);
     return;
@@ -479,26 +746,78 @@ function hookUninstallCommand() {
     "g"
   );
   const updated = existing.replace(pattern, "").replace(/\n{3,}/g, "\n\n");
-  fs4.writeFileSync(rcFile, updated, "utf-8");
+  fs5.writeFileSync(rcFile, updated, "utf-8");
   console.log(`KeepGoing hook removed from ${rcFile}.`);
   console.log(`Reload your shell config to deactivate it:
 `);
   console.log(`  source ${rcFile}`);
 }
 
+// src/commands/activate.ts
+async function activateCommand({ licenseKey }) {
+  if (!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}.`);
+    return;
+  }
+  console.log("Activating license...");
+  const result = await activateLicense(licenseKey, getDeviceId());
+  if (!result.valid) {
+    console.error(`Activation failed: ${result.error ?? "unknown error"}`);
+    process.exit(1);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  writeLicenseCache({
+    licenseKey: result.licenseKey || licenseKey,
+    instanceId: result.instanceId || getDeviceId(),
+    status: "active",
+    lastValidatedAt: now,
+    activatedAt: now,
+    customerName: result.customerName,
+    productName: result.productName
+  });
+  const who = result.customerName ? ` Welcome, ${result.customerName}!` : "";
+  console.log(`Pro license activated successfully.${who}`);
+}
+
+// src/commands/deactivate.ts
+async function deactivateCommand() {
+  const cache = readLicenseCache();
+  if (!cache) {
+    console.log("No active license found on this device.");
+    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);
+  }
+  console.log("Pro license deactivated successfully. The activation slot has been freed.");
+}
+
 // src/index.ts
 var HELP_TEXT = `
 keepgoing: resume side projects without the mental friction
 
 Usage:
-  keepgoing status     Show the last checkpoint for this project
-  keepgoing save       Save a new checkpoint interactively
-  keepgoing hook       Manage the shell hook
+  keepgoing status              Show the last checkpoint for this project
+  keepgoing save                Save a new checkpoint interactively
+  keepgoing hook                Manage the shell hook
+  keepgoing activate <key>      Activate a Pro license on this device
+  keepgoing deactivate          Deactivate the Pro license from this device
 
 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:
@@ -520,6 +839,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) {
@@ -552,6 +873,15 @@ async function main() {
         process.exit(1);
       }
       break;
+    case "version":
+      console.log(`keepgoing v${"0.2.1"}`);
+      break;
+    case "activate":
+      await activateCommand({ licenseKey: subcommand });
+      break;
+    case "deactivate":
+      await deactivateCommand();
+      break;
     case "help":
     case "":
       console.log(HELP_TEXT);

package/package.json

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