@p11-core/cli 0.0.10 → 0.0.11

package/dist/index.js

@@ -3466,8 +3466,11 @@ var require_commander = __commonJS({
 });
 
 // src/index.ts
+import { randomUUID } from "crypto";
 import { realpathSync } from "fs";
 import { chmod, mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "fs/promises";
+import http from "http";
+import https from "https";
 import { createRequire } from "module";
 import { homedir, tmpdir } from "os";
 import path from "path";
@@ -3503,11 +3506,16 @@ var nodeRequire = createRequire(import.meta.url);
 var packageJson = nodeRequire("../package.json");
 var builtDefaultApiUrl = "https://p11.rarexlabs.com";
 var defaultApiUrl = process.env.P11_API_URL || builtDefaultApiUrl;
+var builtPostHogKey = "phc_CftZMyBB3bMZQRj3CmJovHB3kvzwJmQhXSwUBgzUTUi6";
+var builtPostHogHost = "https://us.i.posthog.com";
+var builtAppEnv = "production";
 var generate = nodeRequire("@babel/generator").default;
 var traverse = nodeRequire("@babel/traverse").default;
 var updateCheckIntervalMs = 30 * 60 * 1e3;
 var updateCheckTimeoutMs = 800;
+var telemetryTimeoutMs = 300;
 var P11_HISTORY_FILE = "history.json";
+var P11_TELEMETRY_FILE = "telemetry.json";
 var P11_HISTORY_DIR_MODE = 448;
 var P11_HISTORY_FILE_MODE = 384;
 var P11_HISTORY_LOCK_STALE_MS = 3e4;
@@ -3659,37 +3667,79 @@ Examples:
 
 Environment:
   P11_API_URL    Defaults to ${builtDefaultApiUrl}
-  P11_BUILD_DIR  Directory for temporary share build files. Defaults to the OS temp directory.`
+  P11_BUILD_DIR  Directory for temporary share build files. Defaults to the OS temp directory.
+  P11_TELEMETRY_DISABLED=1 disables anonymous usage analytics.`
   );
   const shareCommand = program2.command("share").description("Share a review link for a page.").argument("[page.tsx]").option("--json", "Print the API response as JSON.").option("--edit-url [url]", "Share a new version using an edit URL or edit id.").option("--api-url [url]", "Override the p11 API URL.").option("--build-dir [dir]", "Directory for temporary build files.").action(async (input, options2) => {
-    await publish(input, normalizePublishOptions(options2));
+    await runCliAction(
+      "share",
+      {
+        has_input: Boolean(input),
+        json: Boolean(options2.json),
+        edit_url: typeof options2.editUrl === "string",
+        api_url_override: typeof options2.apiUrl === "string",
+        build_dir_override: typeof options2.buildDir === "string"
+      },
+      () => publish(input, normalizePublishOptions(options2))
+    );
   });
   allowLegacyParserBehavior(shareCommand);
   const commentsCommand = program2.command("comments").description("Fetch exported comments for a read/edit URL or id.").argument("[readUrl|editUrl|readId|editId]").option("--json", "Print comments as JSON.").option("--output [file]", "Write comments JSON to a file.").option("--version [n]", "Fetch comments for a specific page version.").option("--api-url [url]", "Override the p11 API URL.").action(async (target, options2) => {
-    await comments(target, normalizeCommentsOptions(options2));
+    await runCliAction(
+      "comments",
+      {
+        has_target: Boolean(target),
+        json: Boolean(options2.json),
+        output: typeof options2.output === "string",
+        version: typeof options2.version === "string",
+        api_url_override: typeof options2.apiUrl === "string"
+      },
+      () => comments(target, normalizeCommentsOptions(options2))
+    );
   });
   allowLegacyParserBehavior(commentsCommand);
   const deleteCommand = program2.command("delete").description("Delete a document and all of its versions and comments.").argument("[editUrl|editId]").option("--json", "Print the API response as JSON.").option("--api-url [url]", "Override the p11 API URL.").action(async (target, options2) => {
-    await deleteDocument(target, normalizeDeleteOptions(options2));
+    await runCliAction(
+      "delete",
+      {
+        has_target: Boolean(target),
+        json: Boolean(options2.json),
+        api_url_override: typeof options2.apiUrl === "string"
+      },
+      () => deleteDocument(target, normalizeDeleteOptions(options2))
+    );
   });
   allowLegacyParserBehavior(deleteCommand);
   program2.command("version").description("Print the p11 CLI version.").action(async () => {
-    await warnBeforeAction({ force: true });
-    console.log(packageJson.version);
+    await runCliAction("version", {}, async () => {
+      await warnBeforeAction({ force: true });
+      console.log(packageJson.version);
+    });
   });
   program2.command("history").description("List saved read/edit links.").option("--json", "Print saved history as JSON.").action(async (options2) => {
-    await history(normalizeHistoryOptions(options2));
+    await runCliAction("history", { json: Boolean(options2.json) }, () => history(normalizeHistoryOptions(options2)));
   });
   const docsCommand = program2.command("docs").description("Print p11 authoring docs.").argument("[topic]", "Docs topic: components or sharing.").action(async (topic) => {
-    await docs(topic);
+    await runCliAction("docs", { has_topic: Boolean(topic), known_topic: isKnownDocsTopic(topic) }, () => docs(topic));
   });
   allowLegacyParserBehavior(docsCommand);
   const exampleCommand = program2.command("example").description("Print or write a p11 example document.").argument("[name]", "Example name: minimal or all.").option("--output [file]", "Write the example to a file.").action(async (name, options2) => {
-    await example(name, normalizeExampleOptions(options2));
+    await runCliAction(
+      "example",
+      {
+        has_example: Boolean(name),
+        known_example: isKnownExampleName(name),
+        output: typeof options2.output === "string"
+      },
+      () => example(name, normalizeExampleOptions(options2))
+    );
   });
   allowLegacyParserBehavior(exampleCommand);
   return program2;
 }
+var __testing = {
+  captureCliTelemetry: captureCliTelemetryNow
+};
 function isKnownTopLevelCommand(program2, command) {
   return command === "--help" || command === "-h" || isVersionFlag(command) || command === "help" || program2.commands.some((subcommand) => subcommand.name() === command);
 }
@@ -3699,6 +3749,31 @@ function isVersionFlag(command) {
 function allowLegacyParserBehavior(command) {
   return command.allowUnknownOption().allowExcessArguments();
 }
+function isKnownDocsTopic(topic) {
+  return docsTopics.has(topic ?? "index");
+}
+function isKnownExampleName(name) {
+  return name === void 0 || exampleFiles.has(name);
+}
+async function runCliAction(command, properties, action) {
+  const startedAt = Date.now();
+  try {
+    await action();
+    captureCliTelemetry("p11_cli_command_succeeded", {
+      command,
+      duration_ms: Date.now() - startedAt,
+      ...properties
+    });
+  } catch (error) {
+    await captureCliTelemetryNow("p11_cli_command_failed", {
+      command,
+      duration_ms: Date.now() - startedAt,
+      error_name: error instanceof Error ? error.name : "Error",
+      ...properties
+    });
+    throw error;
+  }
+}
 function normalizePublishOptions(options) {
   return {
     json: options.json,
@@ -4037,6 +4112,130 @@ function delay(ms) {
 function historyFilePath() {
   return path.join(homedir(), ".p11", P11_HISTORY_FILE);
 }
+function captureCliTelemetry(event, properties = {}) {
+  scheduleTelemetry(() => captureCliTelemetryNow(event, properties, { keepAlive: false }));
+}
+async function captureCliTelemetryNow(event, properties = {}, options = {}) {
+  const key = postHogKey();
+  if (!key) return;
+  try {
+    const host = postHogHost();
+    const { anonymousId, isNew } = await telemetryIdentity();
+    const baseProperties = cliTelemetryBaseProperties();
+    const events = [];
+    if (isNew && event !== "p11_cli_activated") {
+      events.push(sendPostHogEvent(host, key, "p11_cli_activated", anonymousId, baseProperties, options));
+    }
+    events.push(sendPostHogEvent(host, key, event, anonymousId, { ...baseProperties, ...properties }, options));
+    await Promise.all(events);
+  } catch {
+  }
+}
+function scheduleTelemetry(task) {
+  const run = () => {
+    task().catch(() => {
+    });
+  };
+  if (typeof setImmediate === "function") {
+    setImmediate(run);
+    return;
+  }
+  setTimeout(run, 0);
+}
+async function sendPostHogEvent(host, key, event, distinctId, properties, options = {}) {
+  const payload = JSON.stringify({
+    api_key: key,
+    event,
+    distinct_id: distinctId,
+    properties: compactObject(properties)
+  });
+  const endpoint = new URL("/capture/", host);
+  const client = endpoint.protocol === "http:" ? http : https;
+  await new Promise((resolve, reject) => {
+    const request = client.request(
+      endpoint,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "content-length": Buffer.byteLength(payload)
+        }
+      },
+      (response) => {
+        response.resume();
+        response.on("end", resolve);
+      }
+    );
+    const timeout = setTimeout(() => {
+      request.destroy(new Error("Telemetry request timed out."));
+    }, telemetryTimeoutMs);
+    if (options.keepAlive === false) timeout.unref?.();
+    request.on("socket", (socket) => {
+      if (options.keepAlive === false) socket.unref();
+    });
+    request.on("error", reject);
+    request.on("close", () => clearTimeout(timeout));
+    request.end(payload);
+  });
+}
+function cliTelemetryBaseProperties() {
+  return {
+    product: "p11",
+    surface: "cli",
+    app_env: analyticsEnv(),
+    cli_version: packageJson.version,
+    node_version: process.versions.node,
+    platform: process.platform,
+    arch: process.arch
+  };
+}
+function postHogKey() {
+  if (isTruthyEnv(process.env.P11_TELEMETRY_DISABLED) || isTruthyEnv(process.env.DO_NOT_TRACK)) return "";
+  return (process.env.P11_POSTHOG_KEY || builtPostHogKey || "").trim();
+}
+function postHogHost() {
+  const rawHost = (process.env.P11_POSTHOG_HOST || builtPostHogHost || "https://us.i.posthog.com").trim();
+  try {
+    return new URL(rawHost.endsWith("/") ? rawHost : `${rawHost}/`);
+  } catch {
+    return new URL("https://us.i.posthog.com/");
+  }
+}
+function isTruthyEnv(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+function analyticsEnv() {
+  return (process.env.APP_ENV || builtAppEnv || "production").trim() || "production";
+}
+async function telemetryIdentity() {
+  const filePath = telemetryFilePath();
+  const raw = await readFile(filePath, "utf8").catch(() => null);
+  if (raw) {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.anonymousId === "string" && /^anon_[A-Za-z0-9-]{12,80}$/.test(parsed.anonymousId)) {
+      return {
+        anonymousId: parsed.anonymousId,
+        isNew: false
+      };
+    }
+  }
+  const data = {
+    anonymousId: `anon_${randomUUID()}`,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const telemetryDir = path.dirname(filePath);
+  await ensurePrivateHistoryDir(telemetryDir);
+  await writeFile(filePath, `${JSON.stringify(data, null, 2)}
+`, { mode: P11_HISTORY_FILE_MODE });
+  await chmod(filePath, P11_HISTORY_FILE_MODE);
+  return {
+    anonymousId: data.anonymousId,
+    isNew: true
+  };
+}
+function telemetryFilePath() {
+  return path.join(homedir(), ".p11", P11_TELEMETRY_FILE);
+}
 function commentsExportJson(data) {
   return JSON.stringify(commentExportData(data), null, 2);
 }
@@ -4544,6 +4743,7 @@ function parseUrlVersion(value) {
   }
 }
 export {
+  __testing,
   addSourceLineAttributes,
   appendPublishHistory,
   buildPageModule,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@p11-core/cli",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "license": "UNLICENSED",
   "type": "module",
   "bin": {