at-builder 1.4.5 → 1.5.0

package/bin/services/telemetry.js

@@ -0,0 +1,320 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trackTelemetry = void 0;
+var os_1 = __importDefault(require("os"));
+var fs_1 = __importDefault(require("fs"));
+var path_1 = __importDefault(require("path"));
+var crypto_1 = __importDefault(require("crypto"));
+var child_process_1 = require("child_process");
+var axios_1 = __importDefault(require("axios"));
+var config_1 = require("../constants/config");
+var logger_1 = __importDefault(require("./logger"));
+// Generate a unique identifier for this CLI execution run
+var eventId = crypto_1.default.randomUUID();
+var startTime = performance.now();
+// Cache user details to avoid multiple shell exec calls
+var cachedUser = null;
+var getUserDetails = function () {
+    if (cachedUser)
+        return cachedUser;
+    var osUsername = os_1.default.userInfo().username || process.env.USER || process.env.USERNAME || "unknown";
+    var gitEmail;
+    var gitName;
+    try {
+        gitEmail = (0, child_process_1.execSync)("git config user.email", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch (e) {
+        // Git config email not set or not in a git repo
+    }
+    try {
+        gitName = (0, child_process_1.execSync)("git config user.name", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch (e) {
+        // Git config name not set or not in a git repo
+    }
+    cachedUser = {
+        osUsername: osUsername,
+        gitEmail: gitEmail || undefined,
+        gitName: gitName || undefined,
+    };
+    return cachedUser;
+};
+// Sanitize command line arguments to avoid logging sensitive information
+var sanitizeArgs = function (args) {
+    return args.map(function (arg) {
+        // Redact any argument value that looks like a secret, token, key or password
+        var lowercaseArg = arg.toLowerCase();
+        if (lowercaseArg.includes("secret") ||
+            lowercaseArg.includes("token") ||
+            lowercaseArg.includes("key") ||
+            lowercaseArg.includes("password")) {
+            // If it's an option value like --token=12345 or similar, redact the value part
+            if (arg.includes("=")) {
+                var parts = arg.split("=");
+                return "".concat(parts[0], "=[REDACTED]");
+            }
+            return "[REDACTED]";
+        }
+        return arg;
+    });
+};
+/**
+ * Retrieves or generates a persistent client ID for Google Analytics user identification.
+ */
+var getClientId = function () {
+    try {
+        var telemetryDir = path_1.default.join(os_1.default.homedir(), ".atb-builder");
+        var clientIdFile = path_1.default.join(telemetryDir, "client_id");
+        if (!fs_1.default.existsSync(telemetryDir)) {
+            fs_1.default.mkdirSync(telemetryDir, { recursive: true });
+        }
+        if (fs_1.default.existsSync(clientIdFile)) {
+            return fs_1.default.readFileSync(clientIdFile, "utf8").trim();
+        }
+        var newClientId = crypto_1.default.randomUUID();
+        fs_1.default.writeFileSync(clientIdFile, newClientId, "utf8");
+        return newClientId;
+    }
+    catch (e) {
+        return crypto_1.default.randomUUID(); // Fallback to transient random if file access fails
+    }
+};
+/**
+ * Sends telemetry event to a remote custom endpoint if configured.
+ */
+var sendRemoteTelemetry = function (url, payload) { return __awaiter(void 0, void 0, void 0, function () {
+    var error_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 2, , 3]);
+                logger_1.default.info("telemetry", "Sending telemetry to ".concat(url));
+                // We set a 500ms timeout to ensure we don't hold up CLI execution.
+                return [4 /*yield*/, axios_1.default.post(url, payload, {
+                        headers: { "Content-Type": "application/json" },
+                        timeout: 500,
+                    })];
+            case 1:
+                // We set a 500ms timeout to ensure we don't hold up CLI execution.
+                _a.sent();
+                logger_1.default.info("telemetry", "Remote telemetry event successfully sent");
+                return [3 /*break*/, 3];
+            case 2:
+                error_1 = _a.sent();
+                // Silence telemetry send errors so the CLI never fails due to tracking issues
+                logger_1.default.error("telemetry", "Failed to send remote telemetry: ".concat(error_1.message));
+                return [3 /*break*/, 3];
+            case 3: return [2 /*return*/];
+        }
+    });
+}); };
+/**
+ * Sends telemetry event to Google Analytics 4 via Measurement Protocol.
+ */
+var sendGA4Telemetry = function (measurementId, apiSecret, payload) { return __awaiter(void 0, void 0, void 0, function () {
+    var url, clientId, userEmail, gaPayload, error_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                // If placeholders are present, do not attempt to send
+                if (!measurementId ||
+                    measurementId === "YOUR_GA_MEASUREMENT_ID" ||
+                    !apiSecret ||
+                    apiSecret === "YOUR_GA_API_SECRET") {
+                    logger_1.default.info("telemetry", "GA4 telemetry credentials not configured");
+                    return [2 /*return*/];
+                }
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                url = "https://www.google-analytics.com/mp/collect?measurement_id=".concat(measurementId, "&api_secret=").concat(apiSecret);
+                clientId = getClientId();
+                userEmail = payload.user.gitEmail || payload.user.osUsername;
+                gaPayload = {
+                    client_id: clientId,
+                    user_id: userEmail,
+                    events: [
+                        {
+                            name: "atb_command_run",
+                            params: {
+                                command: payload.command,
+                                status: payload.execution.status,
+                                duration_ms: payload.execution.durationMs || 0,
+                                error_message: payload.execution.errorMessage || "",
+                                os_username: payload.user.osUsername,
+                                git_email: payload.user.gitEmail || "",
+                                git_name: payload.user.gitName || "",
+                                project_name: payload.project.projectName,
+                                project_path: payload.project.projectPath,
+                                tenant: payload.project.tenant,
+                                platform: payload.system.platform,
+                                node_version: payload.system.nodeVersion,
+                                cli_version: payload.system.cliVersion,
+                            },
+                        },
+                    ],
+                };
+                logger_1.default.info("telemetry", "Sending GA4 event for command: ".concat(payload.command));
+                return [4 /*yield*/, axios_1.default.post(url, gaPayload, {
+                        headers: { "Content-Type": "application/json" },
+                        timeout: 800, // 800ms timeout for GA4 request
+                    })];
+            case 2:
+                _a.sent();
+                logger_1.default.info("telemetry", "GA4 telemetry event successfully sent");
+                return [3 /*break*/, 4];
+            case 3:
+                error_2 = _a.sent();
+                logger_1.default.error("telemetry", "Failed to send GA4 telemetry: ".concat(error_2.message));
+                return [3 /*break*/, 4];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+/**
+ * Appends telemetry event to a local log file in the user's home directory.
+ */
+var writeLocalTelemetry = function (payload) {
+    try {
+        var telemetryDir = path_1.default.join(os_1.default.homedir(), ".atb-builder");
+        var telemetryFile = path_1.default.join(telemetryDir, "telemetry.jsonl");
+        if (!fs_1.default.existsSync(telemetryDir)) {
+            fs_1.default.mkdirSync(telemetryDir, { recursive: true });
+        }
+        fs_1.default.appendFileSync(telemetryFile, JSON.stringify(payload) + "\n", "utf8");
+        logger_1.default.info("telemetry", "Appended telemetry to ".concat(telemetryFile));
+    }
+    catch (error) {
+        logger_1.default.error("telemetry", "Failed to write local telemetry: ".concat(error.message));
+    }
+};
+/**
+ * Tracks a CLI execution event.
+ *
+ * @param command - The command name
+ * @param status - Execution status
+ * @param err - Error if the status is "failed"
+ */
+var trackTelemetry = function (command, status, err) { return __awaiter(void 0, void 0, void 0, function () {
+    var cwd, envVars, e_1, isEnabled, cliVersion, userDetails, customUser, durationMs, tenant, projectName, payload, telemetryUrl, measurementId, apiSecret, e_2;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                _a.trys.push([0, 10, , 11]);
+                cwd = process.cwd();
+                envVars = {};
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, (0, config_1.getENV)(cwd)];
+            case 2:
+                envVars = _a.sent();
+                return [3 /*break*/, 4];
+            case 3:
+                e_1 = _a.sent();
+                return [3 /*break*/, 4];
+            case 4:
+                isEnabled = envVars.TELEMETRY_ENABLED !== "false" && process.env.TELEMETRY_ENABLED !== "false";
+                if (!isEnabled) {
+                    logger_1.default.info("telemetry", "Telemetry is disabled via configuration");
+                    return [2 /*return*/];
+                }
+                return [4 /*yield*/, (0, config_1.getVersion)()];
+            case 5:
+                cliVersion = _a.sent();
+                userDetails = getUserDetails();
+                customUser = envVars.TELEMETRY_USER || process.env.TELEMETRY_USER;
+                if (customUser) {
+                    userDetails.customUser = customUser;
+                }
+                durationMs = status !== "started" ? Math.round(performance.now() - startTime) : undefined;
+                tenant = envVars.ADOBE_TENANT || "";
+                projectName = path_1.default.basename(cwd);
+                payload = {
+                    eventId: eventId,
+                    timestamp: new Date().toISOString(),
+                    command: command,
+                    args: sanitizeArgs(process.argv.slice(2)), // capture all command line arguments starting from index 2
+                    user: userDetails,
+                    project: {
+                        projectName: projectName,
+                        projectPath: cwd,
+                        tenant: tenant,
+                    },
+                    execution: {
+                        status: status,
+                        durationMs: durationMs,
+                        errorMessage: err === null || err === void 0 ? void 0 : err.message,
+                    },
+                    system: {
+                        platform: os_1.default.platform(),
+                        nodeVersion: process.version,
+                        cliVersion: cliVersion,
+                    },
+                };
+                // Always write to local log file for auditing
+                writeLocalTelemetry(payload);
+                if (!(status !== "started")) return [3 /*break*/, 9];
+                telemetryUrl = envVars.TELEMETRY_URL || process.env.TELEMETRY_URL;
+                if (!telemetryUrl) return [3 /*break*/, 7];
+                return [4 /*yield*/, sendRemoteTelemetry(telemetryUrl, payload)];
+            case 6:
+                _a.sent();
+                _a.label = 7;
+            case 7:
+                measurementId = envVars.GA_MEASUREMENT_ID || process.env.GA_MEASUREMENT_ID || "G-K9GL7DDSE5";
+                apiSecret = envVars.GA_API_SECRET || process.env.GA_API_SECRET || "WVnUPXFAR2GRtOEn_0EDPg";
+                return [4 /*yield*/, sendGA4Telemetry(measurementId, apiSecret, payload)];
+            case 8:
+                _a.sent();
+                _a.label = 9;
+            case 9: return [3 /*break*/, 11];
+            case 10:
+                e_2 = _a.sent();
+                // Catch-all to make sure telemetry never crashes CLI commands
+                logger_1.default.error("telemetry", "Error in telemetry tracker: ".concat(e_2.message));
+                return [3 /*break*/, 11];
+            case 11: return [2 /*return*/];
+        }
+    });
+}); };
+exports.trackTelemetry = trackTelemetry;

package/package.json

@@ -1,10 +1,21 @@
 {
     "name": "at-builder",
-    "version": "1.4.5",
+    "version": "1.5.0",
     "main": "bin/index.js",
     "bin": {
         "atb": "bin/index.js"
     },
+    "files": [
+        "bin/",
+        "lib/",
+        ".plop/",
+        "plopfile.js",
+        "puppeteer.js",
+        "webpack.config.js",
+        "babel.config.js",
+        "eslint.config.js",
+        "tsconfig.json"
+    ],
     "scripts": {
         "build:atb": "tsc",
         "build:atb:dev": "tsc -w",

package/.vscode/settings.json

@@ -1,6 +0,0 @@
-{
-    "Slingshot.enableAutomaticCreationOfFilesWithFilenameClick": true,
-    "[handlebars]": {
-        "editor.formatOnSave": false
-    }
-}

package/DEVELOPMENT.md

@@ -1,164 +0,0 @@
-# Local Development
-
-Notes-to-self on how to test `at-builder` against a real consumer project before publishing to npm. Not for end users — this is internal.
-
----
-
-## TL;DR
-
-```bash
-# one-time setup in this repo
-yarn link
-yarn build:atb:dev &              # leave running; recompiles TS on save
-
-# work against the bundled test/ sandbox (already gitignored, pre-populated)
-cd test
-atb doctor
-atb new
-atb dev --browser
-# ... etc
-```
-
-When done:
-
-```bash
-# in at-builder
-yarn unlink
-```
-
----
-
-## Two patterns
-
-### 1. `yarn link` — active iteration
-
-Symlinks the global `atb` binary to this repo. Edits to source are picked up on the next invocation (after rebuild for TypeScript).
-
-```bash
-# in at-builder
-yarn link        # or: npm link
-```
-
-`atb` is now a global command pointing at this repo. Run it from any directory.
-
-To remove the symlink later:
-
-```bash
-yarn unlink                  # in at-builder
-yarn unlink at-builder       # in any project that also linked it (rarely needed)
-```
-
-### 2. `npm pack` — pre-publish verification
-
-`yarn link` uses symlinks, which can paper over packaging issues — forgotten `.npmignore` exclusions, missing bundled assets (like `at-builder-*.vsix`), files declared in `package.json` but not actually present, etc. Before `npm publish`, do this to test the **actual artifact** npm will ship:
-
-```bash
-# in at-builder
-yarn build:atb                # ensure bin/ is fresh
-npm pack                      # produces at-builder-<version>.tgz
-
-# in a clean throwaway directory
-mkdir /tmp/atb-publish-test && cd /tmp/atb-publish-test
-npm install -g /path/to/at-builder/at-builder-<version>.tgz
-
-# verify the published surface
-which atb
-atb --version
-atb install-extension --editor code   # confirms the bundled .vsix actually shipped
-atb init
-# ... exercise other commands
-
-# cleanup
-npm uninstall -g at-builder
-rm /path/to/at-builder/at-builder-<version>.tgz
-```
-
-If anything's missing from the tarball, this catches it before users do.
-
----
-
-## What needs rebuilding
-
-The single thing that bites people most often:
-
-| You edit | Rebuild needed? |
-|---|---|
-| `src/**/*.ts` (CLI surface) | **Yes** — `yarn build:atb` (one-shot) or `yarn build:atb:dev` (`tsc -w`) running in another terminal |
-| `lib/at-deploy.js`, `lib/at-sync.js` | No — plain JS, picked up directly on next `atb` invocation |
-| `puppeteer.js` | No |
-| `webpack.config.js` | No |
-| `.plop/generators/*`, `.plop/templates/*` | No |
-| `babel.config.js`, `eslint.config.js`, `tsconfig.json` | No |
-
-Easiest workflow: open a second terminal in this repo and leave `yarn build:atb:dev` running. Then any `src/` edit is reflected on the next `atb` invocation in your test project.
-
----
-
-## The bundled `test/` sandbox
-
-This repo ships a `test/` directory (gitignored) pre-populated with `.env`, `adobe.config.js`, `.gitignore`, and `package.json` — basically what `atb init` would create. Use it as a throwaway consumer project:
-
-```bash
-cd test
-atb doctor                    # exercises all checks
-atb doctor --fix              # exercises all auto-fixes (incl. watch-config migration)
-atb new                       # exercise the prompts (AB/XT, page names)
-atb sync                      # if you've set activityInfo.id
-atb dev --browser             # exercise the puppeteer fixes
-atb deploy --dry-run          # test deploy logic without PUTting to AT
-atb install-extension         # test the .vsix install flow
-```
-
-If `test/` ever gets corrupted, just delete its contents and re-run `atb init` — it'll regenerate from scratch.
-
----
-
-## Publishing checklist
-
-Before `npm publish`:
-
-1. `yarn build:atb` — ensure `bin/` is fresh and committed.
-2. Bump `version` in `package.json`. Use semver:
-   - **patch** — bug fixes, doc changes
-   - **minor** — new commands, new flags, backwards-compatible features
-   - **major** — breaking schema changes (e.g. requiring fields, renaming commands)
-3. `npm pack` and run the verification block above.
-4. `git tag v<version>` + `git push --tags`.
-5. `npm publish`.
-
----
-
-## Common gotchas
-
-- **`atb` runs the wrong copy (link vs global)** — you have at-builder installed globally from npm AND linked locally. Run `which atb` and `atb --version`; if it doesn't match the local repo, `yarn unlink at-builder` (in linked consumer dirs) and `npm uninstall -g at-builder` to clear stale globals before re-linking.
-- **`atb` resolves to a stale install in a *different* npm prefix** — distinct from the link-vs-global case above. It's easy to end up with at-builder installed at multiple locations (e.g. `/usr/local/lib/node_modules/at-builder` from a system npm AND `~/.nvm/versions/node/<v>/lib/node_modules/at-builder` from nvm). `npm install -g` only writes to the prefix the *currently-active* `npm` uses; a stale install in the *other* prefix can still come first on PATH. Diagnose:
-
-  ```bash
-  which -a atb                       # every atb on PATH
-  npm config get prefix              # where the active npm installs
-  ls -la $(which atb)                # see where the symlink points
-  ```
-
-  If `which -a` lists multiple entries, remove the stale one(s):
-
-  ```bash
-  # active prefix is nvm but a stale /usr/local install is shadowing it:
-  rm -f /usr/local/bin/atb
-  rm -rf /usr/local/lib/node_modules/at-builder
-
-  # or the reverse:
-  rm -f ~/.nvm/versions/node/<v>/bin/atb
-  rm -rf ~/.nvm/versions/node/<v>/lib/node_modules/at-builder
-  ```
-
-  Then reinstall once: `npm install -g /path/to/at-builder-<version>.tgz`.
-
-- **`atb --version` shows the same number after re-packing** — `npm pack` honors whatever's in `package.json`; it doesn't bump for you. If you forgot to update the version before packing, the tarball reports the same number as the previously-published release and `atb --version` looks like nothing changed even though the code did. Always bump `package.json` first (see the publishing checklist for the semver rules), then re-pack. Verify before installing:
-
-  ```bash
-  tar xzOf at-builder-<version>.tgz package/package.json | grep '"version"'
-  ```
-
-- **Edits to `src/` not reflected** — `bin/` is stale. Run `yarn build:atb` or check `yarn build:atb:dev` is actually running.
-- **`npm install` exits 1** — historical issue, the `postinstall` script referenced a missing `bin/postinstall.js`. Already fixed (commit `d3fe05e`); if it resurfaces, drop the `postinstall` line from `package.json` again.
-- **`.vsix` not in tarball** — verify with `npm pack --dry-run` before publishing. The `.vsix` lives at the repo root and is included by default (no `files` field, no `.npmignore` excluding it). If you ever add a `files` field, remember to whitelist `at-builder-*.vsix`.