@keepgoingdev/cli 0.1.1 → 0.2.0

package/dist/index.js

@@ -52,20 +52,49 @@ 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;
+  }
+}
 function getCurrentBranch(workspacePath) {
   try {
     const result = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
@@ -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,112 @@ 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";
+async function activateLicense(licenseKey, instanceName) {
+  try {
+    const res = await fetch(`${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})` };
+    }
+    return {
+      valid: true,
+      licenseKey: data.license_key?.key,
+      instanceId: data.instance?.id,
+      customerName: data.meta?.customer_name,
+      productName: data.meta?.product_name
+    };
+  } catch (err) {
+    return { valid: false, error: err instanceof Error ? err.message : "Network error" };
+  }
+}
+async function deactivateLicense(licenseKey, instanceId) {
+  try {
+    const res = await fetch(`${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})` };
+    }
+    return { deactivated: true };
+  } catch (err) {
+    return { deactivated: false, error: err instanceof Error ? err.message : "Network error" };
+  }
+}
+
+// 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 +338,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 +382,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;
@@ -337,7 +470,7 @@ async function statusCommand(opts) {
 
 // src/commands/save.ts
 import readline from "readline";
-import path4 from "path";
+import path6 from "path";
 function prompt(rl, question) {
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
@@ -381,16 +514,16 @@ async function saveCommand(opts) {
     workspaceRoot: opts.cwd,
     source: "manual"
   });
-  const projectName = path4.basename(opts.cwd);
+  const projectName = path6.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 path7 from "path";
+import os2 from "os";
 var HOOK_MARKER_START = "# keepgoing-hook-start";
 var HOOK_MARKER_END = "# keepgoing-hook-end";
 var ZSH_HOOK = `${HOOK_MARKER_START}
@@ -416,12 +549,12 @@ fi
 ${HOOK_MARKER_END}`;
 function detectShellRcFile() {
   const shellEnv = process.env["SHELL"] ?? "";
-  const home = os.homedir();
+  const home = os2.homedir();
   if (shellEnv.endsWith("zsh")) {
-    return { shell: "zsh", rcFile: path5.join(home, ".zshrc") };
+    return { shell: "zsh", rcFile: path7.join(home, ".zshrc") };
   }
   if (shellEnv.endsWith("bash")) {
-    return { shell: "bash", rcFile: path5.join(home, ".bashrc") };
+    return { shell: "bash", rcFile: path7.join(home, ".bashrc") };
   }
   return void 0;
 }
@@ -437,14 +570,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 +596,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,21 +612,72 @@ 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)
@@ -552,6 +736,12 @@ async function main() {
         process.exit(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.0",
   "description": "Terminal CLI for KeepGoing. Resume side projects without the mental friction.",
   "type": "module",
   "main": "./dist/index.js",