@keepgoingdev/cli 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,10 +1,5 @@
 #!/usr/bin/env node
 
-// src/storage.ts
-import fs from "fs";
-import path from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-
 // ../../packages/shared/src/session.ts
 import { randomUUID } from "crypto";
 function generateCheckpointId() {
@@ -57,8 +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 gitCommonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+      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);
+  } 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"], {
@@ -93,79 +129,25 @@ function getRecentSessions(allSessions, count = RECENT_SESSION_COUNT) {
   return allSessions.slice(-count).reverse();
 }
 
-// src/storage.ts
+// ../../packages/shared/src/storage.ts
+import fs from "fs";
+import path2 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 var STORAGE_DIR = ".keepgoing";
 var META_FILE = "meta.json";
 var SESSIONS_FILE = "sessions.json";
 var STATE_FILE = "state.json";
-var KeepGoingReader = class {
-  storagePath;
-  metaFilePath;
-  sessionsFilePath;
-  stateFilePath;
-  constructor(workspacePath) {
-    this.storagePath = path.join(workspacePath, STORAGE_DIR);
-    this.metaFilePath = path.join(this.storagePath, META_FILE);
-    this.sessionsFilePath = path.join(this.storagePath, SESSIONS_FILE);
-    this.stateFilePath = path.join(this.storagePath, STATE_FILE);
-  }
-  exists() {
-    return fs.existsSync(this.storagePath);
-  }
-  getState() {
-    return this.readJsonFile(this.stateFilePath);
-  }
-  getMeta() {
-    return this.readJsonFile(this.metaFilePath);
-  }
-  getSessions() {
-    return this.parseSessions().sessions;
-  }
-  getLastSession() {
-    const { sessions, wrapperLastSessionId } = this.parseSessions();
-    if (sessions.length === 0) {
-      return void 0;
-    }
-    const state = this.getState();
-    if (state?.lastSessionId) {
-      const found = sessions.find((s) => s.id === state.lastSessionId);
-      if (found) return found;
-    }
-    if (wrapperLastSessionId) {
-      const found = sessions.find((s) => s.id === wrapperLastSessionId);
-      if (found) return found;
-    }
-    return sessions[sessions.length - 1];
-  }
-  getRecentSessions(count) {
-    return getRecentSessions(this.getSessions(), count);
-  }
-  parseSessions() {
-    const raw = this.readJsonFile(this.sessionsFilePath);
-    if (!raw) return { sessions: [] };
-    if (Array.isArray(raw)) return { sessions: raw };
-    return { sessions: raw.sessions ?? [], wrapperLastSessionId: raw.lastSessionId };
-  }
-  readJsonFile(filePath) {
-    try {
-      if (!fs.existsSync(filePath)) return void 0;
-      const raw = fs.readFileSync(filePath, "utf-8");
-      return JSON.parse(raw);
-    } catch {
-      return void 0;
-    }
-  }
-};
 var KeepGoingWriter = class {
   storagePath;
   sessionsFilePath;
   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)) {
@@ -191,6 +173,10 @@ var KeepGoingWriter = class {
     }
     sessionsData.sessions.push(checkpoint);
     sessionsData.lastSessionId = checkpoint.id;
+    const MAX_SESSIONS = 200;
+    if (sessionsData.sessions.length > MAX_SESSIONS) {
+      sessionsData.sessions = sessionsData.sessions.slice(-MAX_SESSIONS);
+    }
     fs.writeFileSync(this.sessionsFilePath, JSON.stringify(sessionsData, null, 2), "utf-8");
     const state = {
       lastSessionId: checkpoint.id,
@@ -198,29 +184,213 @@ var KeepGoingWriter = class {
       lastActivityAt: checkpoint.timestamp
     };
     fs.writeFileSync(this.stateFilePath, JSON.stringify(state, null, 2), "utf-8");
+    this.updateMeta(checkpoint.timestamp);
+  }
+  updateMeta(timestamp) {
     let meta;
     try {
       if (fs.existsSync(this.metaFilePath)) {
         meta = JSON.parse(fs.readFileSync(this.metaFilePath, "utf-8"));
-        meta.lastUpdated = checkpoint.timestamp;
+        meta.lastUpdated = timestamp;
       } else {
         meta = {
           projectId: randomUUID2(),
-          createdAt: checkpoint.timestamp,
-          lastUpdated: checkpoint.timestamp
+          createdAt: timestamp,
+          lastUpdated: timestamp
         };
       }
     } catch {
       meta = {
         projectId: randomUUID2(),
-        createdAt: checkpoint.timestamp,
-        lastUpdated: checkpoint.timestamp
+        createdAt: timestamp,
+        lastUpdated: timestamp
       };
     }
     fs.writeFileSync(this.metaFilePath, JSON.stringify(meta, null, 2), "utf-8");
   }
 };
 
+// ../../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();
+
+// ../../packages/shared/src/license.ts
+import crypto from "crypto";
+import fs3 from "fs";
+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";
+var STATE_FILE2 = "state.json";
+var KeepGoingReader = class {
+  storagePath;
+  metaFilePath;
+  sessionsFilePath;
+  stateFilePath;
+  constructor(workspacePath) {
+    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 fs4.existsSync(this.storagePath);
+  }
+  getState() {
+    return this.readJsonFile(this.stateFilePath);
+  }
+  getMeta() {
+    return this.readJsonFile(this.metaFilePath);
+  }
+  getSessions() {
+    return this.parseSessions().sessions;
+  }
+  getLastSession() {
+    const { sessions, wrapperLastSessionId } = this.parseSessions();
+    if (sessions.length === 0) {
+      return void 0;
+    }
+    const state = this.getState();
+    if (state?.lastSessionId) {
+      const found = sessions.find((s) => s.id === state.lastSessionId);
+      if (found) return found;
+    }
+    if (wrapperLastSessionId) {
+      const found = sessions.find((s) => s.id === wrapperLastSessionId);
+      if (found) return found;
+    }
+    return sessions[sessions.length - 1];
+  }
+  getRecentSessions(count) {
+    return getRecentSessions(this.getSessions(), count);
+  }
+  parseSessions() {
+    const raw = this.readJsonFile(this.sessionsFilePath);
+    if (!raw) return { sessions: [] };
+    if (Array.isArray(raw)) return { sessions: raw };
+    return { sessions: raw.sessions ?? [], wrapperLastSessionId: raw.lastSessionId };
+  }
+  readJsonFile(filePath) {
+    try {
+      if (!fs4.existsSync(filePath)) return void 0;
+      const raw = fs4.readFileSync(filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
 // src/render.ts
 var RESET = "\x1B[0m";
 var BOLD = "\x1B[1m";
@@ -300,7 +470,7 @@ async function statusCommand(opts) {
 
 // src/commands/save.ts
 import readline from "readline";
-import path2 from "path";
+import path6 from "path";
 function prompt(rl, question) {
   return new Promise((resolve) => {
     rl.question(question, (answer) => {
@@ -344,16 +514,16 @@ async function saveCommand(opts) {
     workspaceRoot: opts.cwd,
     source: "manual"
   });
-  const projectName = path2.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 fs2 from "fs";
-import path3 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}
@@ -379,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: path3.join(home, ".zshrc") };
+    return { shell: "zsh", rcFile: path7.join(home, ".zshrc") };
   }
   if (shellEnv.endsWith("bash")) {
-    return { shell: "bash", rcFile: path3.join(home, ".bashrc") };
+    return { shell: "bash", rcFile: path7.join(home, ".bashrc") };
   }
   return void 0;
 }
@@ -400,14 +570,14 @@ function hookInstallCommand() {
   const hookBlock = shell === "zsh" ? ZSH_HOOK : BASH_HOOK;
   let existing = "";
   try {
-    existing = fs2.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;
   }
-  fs2.appendFileSync(rcFile, `
+  fs5.appendFileSync(rcFile, `
 ${hookBlock}
 `, "utf-8");
   console.log(`KeepGoing hook installed in ${rcFile}.`);
@@ -426,7 +596,7 @@ function hookUninstallCommand() {
   const { rcFile } = detected;
   let existing = "";
   try {
-    existing = fs2.readFileSync(rcFile, "utf-8");
+    existing = fs5.readFileSync(rcFile, "utf-8");
   } catch {
     console.log(`${rcFile} not found \u2014 nothing to remove.`);
     return;
@@ -442,21 +612,72 @@ function hookUninstallCommand() {
     "g"
   );
   const updated = existing.replace(pattern, "").replace(/\n{3,}/g, "\n\n");
-  fs2.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)
@@ -491,6 +712,7 @@ function parseArgs(argv) {
       subcommand = arg;
     }
   }
+  cwd = findGitRoot(cwd);
   return { command, subcommand, cwd, json, quiet };
 }
 async function main() {
@@ -514,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.0",
+  "version": "0.2.0",
   "description": "Terminal CLI for KeepGoing. Resume side projects without the mental friction.",
   "type": "module",
   "main": "./dist/index.js",