@displaydev/cli 0.20.0 → 0.21.0

package/dist/api-client.js

@@ -312,27 +312,33 @@ export var ApiClient = /*#__PURE__*/ function() {
     "use strict";
     function ApiClient(config) {
         _class_call_check(this, ApiClient);
-        var _config_clientType, _config_version;
+        var _config_clientType, _config_version, _config_clientSource;
         _define_property(this, "baseUrl", void 0);
         _define_property(this, "apiKey", void 0);
         _define_property(this, "clientType", void 0);
         _define_property(this, "version", void 0);
+        _define_property(this, "clientSource", void 0);
         this.baseUrl = config.baseUrl.replace(/\/$/, '');
         this.apiKey = config.apiKey;
         this.clientType = (_config_clientType = config.clientType) !== null && _config_clientType !== void 0 ? _config_clientType : 'mcp-stdio';
         this.version = (_config_version = config.version) !== null && _config_version !== void 0 ? _config_version : '';
+        this.clientSource = (_config_clientSource = config.clientSource) !== null && _config_clientSource !== void 0 ? _config_clientSource : '';
     }
     _create_class(ApiClient, [
         {
             key: "clientHeaders",
             value: /**
    * Build the request-side header set. Always carries `X-Client-Type`;
-   * adds `X-Client-Version` when the client was constructed with one.
+   * adds `X-Client-Version` when the client was constructed with one;
+   * adds `X-Client-Source` when a distribution-channel attribution was
+   * configured.
    */ function clientHeaders(extra) {
                 var headers = _object_spread({
                     'X-Client-Type': this.clientType
                 }, this.version ? {
                     'X-Client-Version': this.version
+                } : {}, this.clientSource ? {
+                    'X-Client-Source': this.clientSource
                 } : {}, extra);
                 return headers;
             }

package/dist/main.js

@@ -273,12 +273,50 @@ function resolvePublicApiUrl() {
     var _process_env_DISPLAYDEV_API_URL;
     return (_process_env_DISPLAYDEV_API_URL = process.env.DISPLAYDEV_API_URL) !== null && _process_env_DISPLAYDEV_API_URL !== void 0 ? _process_env_DISPLAYDEV_API_URL : DEFAULT_API_URL;
 }
+/**
+ * Distribution-channel attribution stash. `--client-source <name>` is
+ * registered on `program` and on every subcommand in the tree (see
+ * `addClientSourceOptionRecursive` at the bottom of this file) and a
+ * `preAction` hook stashes the parsed value before any action runs.
+ * `createClient` and the two unauthenticated `new ApiClient(...)` sites
+ * then read the stash via `resolveClientSource()`.
+ *
+ * Why a global stash instead of threading through every action: there
+ * are ~20 direct-HTTP subcommands and a single resolution path; passing
+ * the value down through each action's opts type would touch every
+ * action handler for a flag that is structurally cross-cutting.
+ *
+ * The flag is also registered on `mcp` so `dsp mcp --client-source foo`
+ * is silently accepted (per spec §1 out-of-scope). The stash gets
+ * populated, but the mcp action builds its `ApiClient` without reading
+ * the stash, so the value never reaches the spawned MCP server's
+ * outgoing requests.
+ *
+ * Precedence: flag > `DISPLAYDEV_CLIENT_SOURCE` env > omitted. An
+ * explicitly empty flag (`--client-source=`) is treated as the user
+ * suppressing attribution: the env fallback is skipped and the header
+ * is omitted. The header is analytics-only; it does not affect audit /
+ * share-notification source normalization (which keys off
+ * `X-Client-Type`).
+ */ var clientSourceFromFlag;
+var clientSourceFlagPassed = false;
+function resolveClientSource() {
+    if (clientSourceFlagPassed) {
+        return clientSourceFromFlag;
+    }
+    var env = process.env.DISPLAYDEV_CLIENT_SOURCE;
+    if (typeof env === 'string' && env.length > 0) {
+        return env;
+    }
+    return undefined;
+}
 function createClient(auth) {
     return new ApiClient({
         baseUrl: auth.apiUrl,
         apiKey: auth.apiKey,
         clientType: 'cli',
-        version: version
+        version: version,
+        clientSource: resolveClientSource()
     });
 }
 var program = new Command().name('dsp').description('display.dev CLI — publish artifacts behind company auth').version(version);
@@ -426,7 +464,8 @@ program.command('publish <path>').description('Publish an HTML or Markdown file.
                         baseUrl: resolvePublicApiUrl(),
                         apiKey: '',
                         clientType: 'cli',
-                        version: version
+                        version: version,
+                        clientSource: resolveClientSource()
                     });
                     _state.label = 10;
                 case 10:
@@ -1094,7 +1133,8 @@ program.command('login').description('Authenticate with display.dev').option('--
                         baseUrl: apiUrl,
                         apiKey: '',
                         clientType: 'cli',
-                        version: version
+                        version: version,
+                        clientSource: resolveClientSource()
                     });
                     if (!(opts.apiKey !== undefined)) return [
                         3,
@@ -2314,4 +2354,61 @@ program.command('mcp').description('Start MCP server over stdin/stdout').action(
         });
     })();
 });
+/**
+ * Register `--client-source <name>` on `program` AND every command in
+ * the tree (top-level + nested under `comment` / `thread` + `mcp`).
+ * This makes the flag parseable at any level — `dsp --client-source
+ * foo publish ...`, `dsp publish --client-source foo ...`,
+ * `dsp comment --client-source foo add ...`, etc. — so the skill
+ * helpers (per spec §4.2 / §4.3 / §4.4) which exec `dsp publish
+ * --client-source … "$@"` work without per-command duplication of
+ * the action signature.
+ *
+ * `mcp` is included so the flag is silently accepted there too. The
+ * mcp action does not call `resolveClientSource()`, so the stashed
+ * value never reaches the spawned MCP server's `ApiClient` (spec §1
+ * out-of-scope).
+ */ function addClientSourceOptionRecursive(cmd) {
+    cmd.option('--client-source <name>', 'Distribution channel attribution (sent as X-Client-Source header for funnel analytics)');
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = cmd.commands[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var child = _step.value;
+            addClientSourceOptionRecursive(child);
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+addClientSourceOptionRecursive(program);
+/**
+ * Resolve the parsed flag value before each action. Program-level
+ * `preAction` hooks fire ahead of every subcommand action, so a single
+ * registration is enough — the callback walks the active command up
+ * through its parents and stops at the first command whose `opts()`
+ * has a string-typed `clientSource` (distinguishing "not passed"
+ * `undefined` from "explicit blank" `''`).
+ */ program.hook('preAction', function(_thisCommand, actionCommand) {
+    var cursor = actionCommand;
+    while(cursor){
+        var val = cursor.opts().clientSource;
+        if (typeof val === 'string') {
+            clientSourceFlagPassed = true;
+            clientSourceFromFlag = val.length > 0 ? val : undefined;
+            return;
+        }
+        cursor = cursor.parent;
+    }
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@displaydev/cli",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "type": "module",
   "bin": {
     "dsp": "dist/main.js"