opencodekit 0.18.11 → 0.18.13

package/dist/index.js

@@ -1,15 +1,17 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
+import * as p from "@clack/prompts";
 import { cac } from "cac";
+import color from "picocolors";
+import { createHash, createHmac } from "node:crypto";
 import { copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir, hostname, platform, release } from "node:os";
 import { basename, dirname, join, relative } from "node:path";
-import * as p from "@clack/prompts";
-import color from "picocolors";
+import envPaths from "env-paths";
+import { machineIdSync } from "node-machine-id";
 import { z } from "zod";
 import { execSync, spawn } from "node:child_process";
-import { homedir, platform } from "node:os";
 import { fileURLToPath } from "node:url";
-import { createHash } from "node:crypto";
 import { applyPatch, createPatch } from "diff";
 import * as readline from "node:readline";
 
@@ -18,7 +20,245 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "0.18.11";
+var version = "0.18.13";
+
+//#endregion
+//#region src/utils/license.ts
+const LICENSE_API_BASE_URL = process.env.OCK_LICENSE_API_BASE_URL ?? "https://payments-api.opencodekit.xyz";
+const LICENSE_REQUEST_TIMEOUT_MS = 1e4;
+const LICENSE_HMAC_SECRET = process.env.OCK_LICENSE_HMAC_SECRET ?? "ock-license-v1-local-integrity";
+const LICENSE_CHECK_INTERVAL_SECONDS = 10080 * 60;
+const LICENSE_OFFLINE_GRACE_SECONDS = 720 * 60 * 60;
+const LICENSE_KEY_PATTERN = /^OCK-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$/;
+const StoredLicenseSchema = z.object({
+	key: z.string(),
+	activationId: z.string(),
+	machineId: z.string(),
+	machineLabel: z.string(),
+	activatedAt: z.number(),
+	lastValidatedAt: z.number(),
+	nextCheckAt: z.number(),
+	hmac: z.string()
+});
+function unixNow() {
+	return Math.floor(Date.now() / 1e3);
+}
+function getLicensePaths() {
+	const paths = envPaths("opencodekit", { suffix: "" });
+	return {
+		dir: join(paths.data, "license"),
+		file: join(paths.data, "license", "license.json")
+	};
+}
+function toSign(payload) {
+	return [
+		payload.key,
+		payload.activationId,
+		payload.machineId,
+		payload.machineLabel,
+		payload.activatedAt,
+		payload.lastValidatedAt,
+		payload.nextCheckAt
+	].join("|");
+}
+function computeHmac(payload) {
+	return createHmac("sha256", LICENSE_HMAC_SECRET).update(toSign(payload), "utf8").digest("hex");
+}
+function getMachineId() {
+	return machineIdSync(false);
+}
+function getMachineLabel() {
+	return `${hostname()} (${platform()} ${release()})`;
+}
+function getLicenseFilePath() {
+	return getLicensePaths().file;
+}
+function readStoredLicense() {
+	const { file } = getLicensePaths();
+	if (!existsSync(file)) return null;
+	try {
+		const raw = readFileSync(file, "utf8");
+		const parsed = StoredLicenseSchema.safeParse(JSON.parse(raw));
+		if (!parsed.success) return null;
+		return parsed.data;
+	} catch {
+		return null;
+	}
+}
+function deleteStoredLicense() {
+	const { file } = getLicensePaths();
+	if (!existsSync(file)) return;
+	rmSync(file, { force: true });
+}
+function isLicenseBypassEnabled() {
+	return process.env.OCK_LICENSE_BYPASS === "1";
+}
+function isLicenseKeyFormatValid(key) {
+	return LICENSE_KEY_PATTERN.test(key.trim().toUpperCase());
+}
+function isStoredLicenseIntegrityValid(stored) {
+	return computeHmac({
+		key: stored.key,
+		activationId: stored.activationId,
+		machineId: stored.machineId,
+		machineLabel: stored.machineLabel,
+		activatedAt: stored.activatedAt,
+		lastValidatedAt: stored.lastValidatedAt,
+		nextCheckAt: stored.nextCheckAt
+	}) === stored.hmac;
+}
+function writeStoredLicense(payload) {
+	const { dir, file } = getLicensePaths();
+	mkdirSync(dir, { recursive: true });
+	const stored = {
+		...payload,
+		hmac: computeHmac(payload)
+	};
+	writeFileSync(file, `${JSON.stringify(stored, null, 2)}\n`, "utf8");
+	return stored;
+}
+async function postJson(path, body) {
+	let response;
+	try {
+		response = await fetch(`${LICENSE_API_BASE_URL}${path}`, {
+			method: "POST",
+			headers: { "content-type": "application/json" },
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(LICENSE_REQUEST_TIMEOUT_MS)
+		});
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`License server request failed: ${message}`);
+	}
+	let data;
+	try {
+		data = await response.json();
+	} catch {
+		throw new Error(`License server returned invalid JSON (${response.status})`);
+	}
+	if (!response.ok) {
+		const maybe = data;
+		throw new Error(maybe?.message || `License server request failed with status ${response.status}`);
+	}
+	return data;
+}
+async function activateLicenseKey(key) {
+	const normalizedKey = key.trim().toUpperCase();
+	const machineId = getMachineId();
+	const machineLabel = getMachineLabel();
+	const now = unixNow();
+	const data = await postJson("/v1/activate", {
+		key: normalizedKey,
+		machine_id: machineId,
+		machine_label: machineLabel
+	});
+	if (!data.ok || !data.activation_id) throw new Error(data.message || data.error || "License activation failed");
+	return writeStoredLicense({
+		key: normalizedKey,
+		activationId: data.activation_id,
+		machineId,
+		machineLabel,
+		activatedAt: now,
+		lastValidatedAt: now,
+		nextCheckAt: now + LICENSE_CHECK_INTERVAL_SECONDS
+	});
+}
+async function validateLicenseOnline(stored) {
+	if (getMachineId() !== stored.machineId) throw new Error("License key is activated on a different machine");
+	const data = await postJson("/v1/validate", {
+		key: stored.key,
+		activation_id: stored.activationId,
+		machine_id: stored.machineId
+	});
+	if (!data.ok) throw new Error(data.message || data.error || "License validation failed");
+	const now = unixNow();
+	writeStoredLicense({
+		key: stored.key,
+		activationId: stored.activationId,
+		machineId: stored.machineId,
+		machineLabel: stored.machineLabel,
+		activatedAt: stored.activatedAt,
+		lastValidatedAt: now,
+		nextCheckAt: now + LICENSE_CHECK_INTERVAL_SECONDS
+	});
+}
+async function deactivateCurrentLicense(stored) {
+	const data = await postJson("/v1/deactivate", {
+		key: stored.key,
+		activation_id: stored.activationId,
+		machine_id: stored.machineId
+	});
+	if (!data.ok) throw new Error(data.message || data.error || "License deactivation failed");
+	deleteStoredLicense();
+}
+async function requireValidLicense() {
+	if (isLicenseBypassEnabled()) return {
+		mode: "bypass",
+		stored: null
+	};
+	const stored = readStoredLicense();
+	if (!stored) throw new Error("License not activated. Run: ock activate <LICENSE_KEY>");
+	if (!isStoredLicenseIntegrityValid(stored)) throw new Error(`License file integrity check failed (${dirname(getLicenseFilePath())}). Re-activate with: ock activate <LICENSE_KEY>`);
+	if (stored.machineId !== getMachineId()) throw new Error("License is tied to a different machine. Run: ock activate <LICENSE_KEY>");
+	const now = unixNow();
+	if (stored.nextCheckAt > now) return {
+		mode: "active",
+		stored
+	};
+	try {
+		await validateLicenseOnline(stored);
+		return {
+			mode: "active",
+			stored: readStoredLicense()
+		};
+	} catch (error) {
+		if (now - stored.lastValidatedAt <= LICENSE_OFFLINE_GRACE_SECONDS) return {
+			mode: "offline-grace",
+			stored
+		};
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`License validation failed: ${message}`);
+	}
+}
+
+//#endregion
+//#region src/commands/activate.ts
+async function activateCommand(keyArg) {
+	p.intro(color.bgBlue(color.black(" License Activation ")));
+	let key = keyArg?.trim();
+	if (!key) {
+		const answer = await p.text({
+			message: "Enter your license key",
+			placeholder: "OCK-XXXX-XXXX-XXXX",
+			validate: (value) => {
+				if (!value) return "License key is required";
+				if (!isLicenseKeyFormatValid(value)) return "Invalid format. Expected OCK-XXXX-XXXX-XXXX";
+			}
+		});
+		if (p.isCancel(answer)) {
+			p.cancel("Cancelled");
+			return;
+		}
+		key = String(answer);
+	}
+	if (!isLicenseKeyFormatValid(key)) {
+		p.log.error("Invalid license key format. Expected OCK-XXXX-XXXX-XXXX");
+		return;
+	}
+	const spinner = p.spinner();
+	spinner.start("Activating license");
+	try {
+		const stored = await activateLicenseKey(key);
+		spinner.stop("License activated");
+		p.log.success(`Activated ${color.cyan(stored.key)}`);
+		p.log.info(`Stored at ${color.dim(getLicenseFilePath())}`);
+		p.outro(color.green("Activation complete"));
+	} catch (error) {
+		spinner.stop("Activation failed");
+		const message = error instanceof Error ? error.message : String(error);
+		p.log.error(message);
+	}
+}
 
 //#endregion
 //#region src/utils/errors.ts
@@ -3353,6 +3593,80 @@ async function initCommand(rawOptions = {}) {
 	p.outro(color.green("Ready to code!"));
 }
 
+//#endregion
+//#region src/commands/license.ts
+async function licenseCommand(action) {
+	const mode = (action ?? "status").trim();
+	if (mode === "status") {
+		await showLicenseStatus();
+		return;
+	}
+	if (mode === "deactivate") {
+		await deactivateLicense();
+		return;
+	}
+	p.log.error(`Unknown action: ${mode}`);
+	p.log.info(`Available: ${color.cyan("status")}, ${color.cyan("deactivate")}`);
+}
+async function showLicenseStatus() {
+	const stored = readStoredLicense();
+	if (!stored) {
+		p.log.warn("No license is currently activated");
+		p.log.info(`Run ${color.cyan("ock activate <LICENSE_KEY>")}`);
+		return;
+	}
+	p.log.info(color.bold("License Status"));
+	console.log(`  key:          ${color.cyan(stored.key)}`);
+	console.log(`  activation:   ${stored.activationId}`);
+	console.log(`  machine:      ${stored.machineLabel}`);
+	console.log(`  last check:   ${(/* @__PURE__ */ new Date(stored.lastValidatedAt * 1e3)).toISOString()}`);
+	console.log(`  next check:   ${(/* @__PURE__ */ new Date(stored.nextCheckAt * 1e3)).toISOString()}`);
+	console.log(`  file:         ${color.dim(getLicenseFilePath())}`);
+	const spinner = p.spinner();
+	spinner.start("Verifying with license server");
+	try {
+		await validateLicenseOnline(stored);
+		spinner.stop("License is valid");
+	} catch (error) {
+		spinner.stop("Validation failed");
+		const message = error instanceof Error ? error.message : String(error);
+		p.log.warn(message);
+	}
+}
+async function deactivateLicense() {
+	const stored = readStoredLicense();
+	if (!stored) {
+		p.log.warn("No license is currently activated");
+		return;
+	}
+	const confirm = await p.confirm({
+		message: `Deactivate license ${stored.key} on this machine?`,
+		initialValue: false
+	});
+	if (p.isCancel(confirm) || !confirm) {
+		p.cancel("Cancelled");
+		return;
+	}
+	const spinner = p.spinner();
+	spinner.start("Deactivating license");
+	try {
+		await deactivateCurrentLicense(stored);
+		spinner.stop("License deactivated");
+		p.outro(color.green("This machine no longer uses the license"));
+	} catch (error) {
+		spinner.stop("Deactivation failed");
+		const message = error instanceof Error ? error.message : String(error);
+		p.log.warn(`Remote deactivation failed: ${message}`);
+		const retry = await p.confirm({
+			message: "Remove local license file anyway?",
+			initialValue: false
+		});
+		if (p.isCancel(retry) || !retry) return;
+		deleteStoredLicense();
+		p.log.info(`Removed local license at ${color.dim(getLicenseFilePath())}`);
+	}
+}
+
 //#endregion
 //#region src/commands/skill.ts
 async function skillCommand(action) {
@@ -5612,10 +5926,32 @@ if (process.stdout.setEncoding) process.stdout.setEncoding("utf8");
 if (process.stderr.setEncoding) process.stderr.setEncoding("utf8");
 const packageVersion = version;
 const cli = cac("ock");
+async function ensureLicenseFor(commandName) {
+	try {
+		if ((await requireValidLicense()).mode === "offline-grace") p.log.warn("License server is unreachable. Running in offline grace mode.");
+		return true;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		p.log.error(`${commandName} requires a valid license`);
+		p.log.info(message);
+		p.log.info("Run: ock activate <LICENSE_KEY>");
+		process.exitCode = 1;
+		return false;
+	}
+}
 cli.option("--verbose", "Enable verbose logging");
 cli.option("--quiet", "Suppress all output");
 cli.version(`${packageVersion}`);
-cli.command("init", "Initialize OpenCodeKit in current directory").option("--force", "Reinitialize even if already exists").option("--beads", "Also initialize .beads/ for multi-agent coordination").option("--global", "Install to global OpenCode config (~/.config/opencode/)").option("--free", "Use free models (default)").option("--recommend", "Use recommended premium models").option("-y, --yes", "Skip prompts, use defaults (for CI)").option("--backup", "Backup existing .opencode before overwriting").option("--prune", "Manually select orphan files to delete").option("--prune-all", "Auto-delete all orphan files").option("--project-only", "Only init project-scope files (skip if global config has agents/skills/commands/tools)").action(initCommand);
+cli.command("init", "Initialize OpenCodeKit in current directory").option("--force", "Reinitialize even if already exists").option("--beads", "Also initialize .beads/ for multi-agent coordination").option("--global", "Install to global OpenCode config (~/.config/opencode/)").option("--free", "Use free models (default)").option("--recommend", "Use recommended premium models").option("-y, --yes", "Skip prompts, use defaults (for CI)").option("--backup", "Backup existing .opencode before overwriting").option("--prune", "Manually select orphan files to delete").option("--prune-all", "Auto-delete all orphan files").option("--project-only", "Only init project-scope files (skip if global config has agents/skills/commands/tools)").action(async (options) => {
+	if (!await ensureLicenseFor("init")) return;
+	await initCommand(options);
+});
+cli.command("activate [key]", "Activate paid license key").action(async (key) => {
+	await activateCommand(key);
+});
+cli.command("license [action]", "Manage license (status, deactivate)").action(async (action) => {
+	await licenseCommand(action);
+});
 cli.command("agent [action]", "Manage agents (list, add, view)").action(async (action) => {
 	if (!action) {
 		console.log("\nUsage: ock agent <action>\n");
@@ -5657,6 +5993,7 @@ cli.command("config [action]", "Edit opencode.json (model, mcp, permission, vali
 	await configCommand(action);
 });
 cli.command("upgrade", "Update .opencode/ templates to latest version").option("--force", "Force upgrade even if already up to date").option("--check", "Check for updates without upgrading").option("--prune", "Manually select orphan files to delete").option("--prune-all", "Auto-delete all orphan files").action(async (options) => {
+	if (!await ensureLicenseFor("upgrade")) return;
 	await upgradeCommand(options);
 });
 cli.command("patch [action]", "Manage template patches (list, create, apply, diff, remove, disable, enable)").action(async (action) => {