@displaydev/cli 0.18.0 → 0.19.0

package/dist/api-client.js

@@ -392,6 +392,141 @@ export var ApiClient = /*#__PURE__*/ function() {
                 }).call(this);
             }
         },
+        {
+            key: "addComment",
+            value: // ── Comments (feat-comments §3) ──────────────────────────────────────
+            // 1:1 with the public REST endpoints under
+            // `/v1/artifacts/:shortId/comments` and `/v1/comments/:commentId/...`.
+            // KB-page subjects 404 until KB ships.
+            function addComment(shortId, params) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            this.request('POST', "/v1/artifacts/".concat(shortId, "/comments"), params)
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "listComments",
+            value: function listComments(shortId, params) {
+                return _async_to_generator(function() {
+                    var qs, suffix;
+                    return _ts_generator(this, function(_state) {
+                        qs = new URLSearchParams();
+                        if (params === null || params === void 0 ? void 0 : params.status) {
+                            qs.set('status', params.status);
+                        }
+                        if (params === null || params === void 0 ? void 0 : params.since) {
+                            qs.set('since', params.since);
+                        }
+                        suffix = qs.toString() ? "?".concat(qs.toString()) : '';
+                        return [
+                            2,
+                            this.request('GET', "/v1/artifacts/".concat(shortId, "/comments").concat(suffix))
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "editComment",
+            value: function editComment(commentId, body) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            this.request('POST', "/v1/comments/".concat(commentId, "/edit"), {
+                                body: body
+                            })
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "deleteComment",
+            value: function deleteComment(commentId) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request('DELETE', "/v1/comments/".concat(commentId))
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "resolveThread",
+            value: function resolveThread(commentId) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            this.request('POST', "/v1/comments/".concat(commentId, "/resolve"))
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "reopenThread",
+            value: function reopenThread(commentId) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            this.request('POST', "/v1/comments/".concat(commentId, "/reopen"))
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "watchArtifact",
+            value: function watchArtifact(shortId) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        return [
+                            2,
+                            this.request('POST', "/v1/artifacts/".concat(shortId, "/watch"))
+                        ];
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "unwatchArtifact",
+            value: function unwatchArtifact(shortId) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.request('DELETE', "/v1/artifacts/".concat(shortId, "/watch"))
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
         {
             key: "buildPublishForm",
             value: function buildPublishForm(params) {
@@ -972,6 +1107,15 @@ export var ApiClient = /*#__PURE__*/ function() {
                                 }
                                 throw new ApiError((_parsed_message = parsed.message) !== null && _parsed_message !== void 0 ? _parsed_message : "API error ".concat(res.status), res.status, parsed.details, parsed.reason, parsed.error);
                             case 3:
+                                // 204 No Content (and 205 Reset Content) carry no body. Calling
+                                // res.json() on them throws SyntaxError; return undefined so void-
+                                // typed callers (deleteComment, unwatchArtifact) are satisfied.
+                                if (res.status === 204 || res.status === 205) {
+                                    return [
+                                        2,
+                                        undefined
+                                    ];
+                                }
                                 return [
                                     2,
                                     res.json()

package/dist/main.js

@@ -1703,6 +1703,537 @@ program.command('clear-logo').description('Remove the org logo (idempotent — s
         });
     })();
 });
+// --- comment add ---
+// `dsp comment add --artifact <shortId> --body "..." --anchor-json '<json>' [--parent <id>]`
+// Spec §3 maps to POST /v1/artifacts/:shortId/comments. Root posts
+// require a full anchor descriptor (textQuote prefix + exact + suffix
+// plus cssPath); replies inherit the root's anchor and must omit it.
+//
+// `--anchor-json` is intentionally the only anchor input. A bare-text
+// shortcut would have to fabricate prefix/suffix/cssPath, and the
+// underlying `dom-anchor-text-quote` resolver binds to the FIRST exact
+// match in the scope. Without prefix/suffix the resolver cannot
+// disambiguate duplicates and the comment can silently attach to the
+// wrong occurrence — see widget's anchor algorithm at
+// webapp/src/components/comments/anchor.ts:54. Forcing the caller to
+// supply the full descriptor (the agent has the source content; humans
+// can copy from the widget's selection JSON) keeps the bind reliable.
+program.command('comment').description('Comment-related subcommands. Run `dsp comment <cmd> --help` for each.').command('add').description('Post a root comment or reply on an artifact.').option('--artifact <shortId>', 'Artifact shortId (subject_type=artifact)').option('--kb-page <kbName...>', 'KB-page subject — pass two values: kb name then file path (subject_type=kb_page; not yet supported). Variadic (commander) — anything after `--kb-page` up to the next flag is consumed as the (kbName, filePath) tuple.').requiredOption('--body <text>', 'Comment body (≤10k chars)').option('--anchor-json <json>', 'Full anchor object as JSON: {"textQuote":{"prefix":"","exact":"...","suffix":""},"cssPath":"..."}. Required for root posts; omit for replies.').option('--parent <commentId>', 'Reply to this root comment id; omit for a root post').action(function(opts) {
+    return _async_to_generator(function() {
+        var subject, anchor, auth, client, result, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    subject = resolveSubjectFlags(opts);
+                    if (subject.kind === 'invalid') {
+                        console.error(subject.error);
+                        process.exit(1);
+                    }
+                    if (subject.kind === 'kb_page') {
+                        console.error('subject_type_not_implemented: KB-page subjects are not yet supported.');
+                        process.exit(1);
+                    }
+                    if (!opts.parent && !opts.anchorJson) {
+                        console.error('Root comments require --anchor-json. Use --parent <commentId> for a reply.');
+                        process.exit(1);
+                    }
+                    if (opts.parent && opts.anchorJson) {
+                        console.error('Replies inherit the root anchor — omit --anchor-json when --parent is set.');
+                        process.exit(1);
+                    }
+                    if (opts.anchorJson) {
+                        try {
+                            anchor = JSON.parse(opts.anchorJson);
+                        } catch (unused) {
+                            console.error('--anchor-json is not valid JSON.');
+                            process.exit(1);
+                        }
+                    }
+                    return [
+                        4,
+                        resolveAuthOrConfig()
+                    ];
+                case 1:
+                    auth = _state.sent();
+                    client = createClient(auth);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        client.addComment(subject.shortId, {
+                            body: opts.body,
+                            anchor: anchor,
+                            parentId: opts.parent
+                        })
+                    ];
+                case 3:
+                    result = _state.sent();
+                    console.log(JSON.stringify(result, null, 2));
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    err = _state.sent();
+                    handleCommentApiError(err);
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+// --- comment list ---
+program.commands.find(function(c) {
+    return c.name() === 'comment';
+}).command('list').description('List comment threads on a subject.').option('--artifact <shortId>', 'Artifact shortId (subject_type=artifact)').option('--kb-page <kbName...>', 'KB-page subject — pass two values: kb name then file path (subject_type=kb_page; not yet supported). Variadic (commander) — anything after `--kb-page` up to the next flag is consumed as the (kbName, filePath) tuple.').option('--status <state>', 'open | resolved | all (default: open)').option('--since <iso>', 'ISO-8601 timestamp — filter to threads with activity at or after this point').action(function(opts) {
+    return _async_to_generator(function() {
+        var subject, auth, client, result, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    subject = resolveSubjectFlags(opts);
+                    if (subject.kind === 'invalid') {
+                        console.error(subject.error);
+                        process.exit(1);
+                    }
+                    if (subject.kind === 'kb_page') {
+                        console.error('subject_type_not_implemented: KB-page subjects are not yet supported.');
+                        process.exit(1);
+                    }
+                    if (opts.status && ![
+                        'open',
+                        'resolved',
+                        'all'
+                    ].includes(opts.status)) {
+                        console.error("Invalid --status: ".concat(opts.status, ". Use open, resolved, or all."));
+                        process.exit(1);
+                    }
+                    return [
+                        4,
+                        resolveAuthOrConfig()
+                    ];
+                case 1:
+                    auth = _state.sent();
+                    client = createClient(auth);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        client.listComments(subject.shortId, {
+                            status: opts.status,
+                            since: opts.since
+                        })
+                    ];
+                case 3:
+                    result = _state.sent();
+                    console.log(JSON.stringify(result, null, 2));
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    err = _state.sent();
+                    handleCommentApiError(err);
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+// --- comment edit ---
+program.commands.find(function(c) {
+    return c.name() === 'comment';
+}).command('edit <commentId>').description('Edit your own comment within the 5-minute author window.').requiredOption('--body <text>', 'New comment body').action(function(commentId, opts) {
+    return _async_to_generator(function() {
+        var auth, client, result, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        resolveAuthOrConfig()
+                    ];
+                case 1:
+                    auth = _state.sent();
+                    client = createClient(auth);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        client.editComment(commentId, opts.body)
+                    ];
+                case 3:
+                    result = _state.sent();
+                    console.log(JSON.stringify(result, null, 2));
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    err = _state.sent();
+                    handleCommentApiError(err);
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+// --- comment delete ---
+program.commands.find(function(c) {
+    return c.name() === 'comment';
+}).command('delete <commentId>').description('Soft-delete a comment. Author / artifact creator / org admin.').action(function(commentId) {
+    return _async_to_generator(function() {
+        var auth, client, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        resolveAuthOrConfig()
+                    ];
+                case 1:
+                    auth = _state.sent();
+                    client = createClient(auth);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        client.deleteComment(commentId)
+                    ];
+                case 3:
+                    _state.sent();
+                    console.log('Comment deleted.');
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    err = _state.sent();
+                    handleCommentApiError(err);
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+// --- thread resolve / reopen ---
+var threadCmd = program.command('thread').description('Thread-level operations (resolve, reopen).');
+threadCmd.command('resolve <rootCommentId>').description('Mark a thread resolved. Thread participant / artifact creator / org admin.').action(function(commentId) {
+    return _async_to_generator(function() {
+        var auth, client, result, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        resolveAuthOrConfig()
+                    ];
+                case 1:
+                    auth = _state.sent();
+                    client = createClient(auth);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        client.resolveThread(commentId)
+                    ];
+                case 3:
+                    result = _state.sent();
+                    console.log(JSON.stringify(result, null, 2));
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    err = _state.sent();
+                    handleCommentApiError(err);
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+threadCmd.command('reopen <rootCommentId>').description('Reopen a resolved thread. Any authenticated user with view access.').action(function(commentId) {
+    return _async_to_generator(function() {
+        var auth, client, result, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    return [
+                        4,
+                        resolveAuthOrConfig()
+                    ];
+                case 1:
+                    auth = _state.sent();
+                    client = createClient(auth);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        client.reopenThread(commentId)
+                    ];
+                case 3:
+                    result = _state.sent();
+                    console.log(JSON.stringify(result, null, 2));
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    err = _state.sent();
+                    handleCommentApiError(err);
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+// --- watch / unwatch ---
+program.command('watch').description('Watch a subject for comment notifications.').option('--artifact <shortId>', 'Artifact shortId (subject_type=artifact)').option('--kb-page <kbName...>', 'KB-page subject — pass two values: kb name then file path (subject_type=kb_page; not yet supported). Variadic (commander) — anything after `--kb-page` up to the next flag is consumed as the (kbName, filePath) tuple.').action(function(opts) {
+    return _async_to_generator(function() {
+        var subject, auth, client, result, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    subject = resolveSubjectFlags(opts);
+                    if (subject.kind === 'invalid') {
+                        console.error(subject.error);
+                        process.exit(1);
+                    }
+                    if (subject.kind === 'kb_page') {
+                        console.error('subject_type_not_implemented: KB-page subjects are not yet supported.');
+                        process.exit(1);
+                    }
+                    return [
+                        4,
+                        resolveAuthOrConfig()
+                    ];
+                case 1:
+                    auth = _state.sent();
+                    client = createClient(auth);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        client.watchArtifact(subject.shortId)
+                    ];
+                case 3:
+                    result = _state.sent();
+                    console.log(JSON.stringify(result, null, 2));
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    err = _state.sent();
+                    handleCommentApiError(err);
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+program.command('unwatch').description('Unwatch a subject.').option('--artifact <shortId>', 'Artifact shortId (subject_type=artifact)').option('--kb-page <kbName...>', 'KB-page subject — pass two values: kb name then file path (subject_type=kb_page; not yet supported). Variadic (commander) — anything after `--kb-page` up to the next flag is consumed as the (kbName, filePath) tuple.').action(function(opts) {
+    return _async_to_generator(function() {
+        var subject, auth, client, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    subject = resolveSubjectFlags(opts);
+                    if (subject.kind === 'invalid') {
+                        console.error(subject.error);
+                        process.exit(1);
+                    }
+                    if (subject.kind === 'kb_page') {
+                        console.error('subject_type_not_implemented: KB-page subjects are not yet supported.');
+                        process.exit(1);
+                    }
+                    return [
+                        4,
+                        resolveAuthOrConfig()
+                    ];
+                case 1:
+                    auth = _state.sent();
+                    client = createClient(auth);
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        client.unwatchArtifact(subject.shortId)
+                    ];
+                case 3:
+                    _state.sent();
+                    console.log('Unwatched.');
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    err = _state.sent();
+                    handleCommentApiError(err);
+                    return [
+                        3,
+                        5
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+});
+function resolveSubjectFlags(opts) {
+    var hasArtifact = Boolean(opts.artifact);
+    var kbPage = opts.kbPage;
+    var hasKbPage = Array.isArray(kbPage) && kbPage.length > 0;
+    if (hasArtifact && hasKbPage) {
+        return {
+            kind: 'invalid',
+            error: 'Pass either --artifact or --kb-page, not both.'
+        };
+    }
+    if (!hasArtifact && !hasKbPage) {
+        return {
+            kind: 'invalid',
+            error: 'Pass --artifact <shortId> or --kb-page <kbName> <filePath>.'
+        };
+    }
+    if (hasArtifact) {
+        return {
+            kind: 'artifact',
+            shortId: opts.artifact
+        };
+    }
+    if (kbPage.length !== 2) {
+        return {
+            kind: 'invalid',
+            error: '--kb-page requires exactly two values: <kbName> <filePath>.'
+        };
+    }
+    return {
+        kind: 'kb_page',
+        kbName: kbPage[0],
+        filePath: kbPage[1],
+        shortId: ''
+    };
+}
+/**
+ * Common error mapper for the comment / watch / thread subcommands.
+ * Mirrors the ApiError handling on share/rename so 401 prompts a
+ * re-login, 403 surfaces the API's reason verbatim, 404 shows a
+ * concrete "not found", and 410 (signed-token failures from the
+ * email-link routes) prints the API's message. Other errors fall
+ * through to a generic stringify.
+ */ function handleCommentApiError(err) {
+    if (_instanceof(err, ApiError)) {
+        if (err.status === 401) {
+            console.error('Your credential is no longer valid. Run: dsp login (or rotate DISPLAYDEV_API_KEY).');
+            process.exit(1);
+        }
+        if (err.status === 404) {
+            console.error(err.message);
+            process.exit(4);
+        }
+        if (err.status === 403 || err.status === 400 || err.status === 410 || err.status === 429) {
+            console.error(err.message);
+            process.exit(1);
+        }
+    }
+    var msg = _instanceof(err, Error) ? err.message : String(err);
+    console.error(msg);
+    process.exit(1);
+}
 // --- mcp ---
 program.command('mcp').description('Start MCP server over stdin/stdout').action(function() {
     return _async_to_generator(function() {

package/dist/mcp-server.js

@@ -27,6 +27,19 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
 function _instanceof(left, right) {
     "@swc/helpers - instanceof";
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
@@ -35,6 +48,45 @@ function _instanceof(left, right) {
         return left instanceof right;
     }
 }
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
 function _ts_generator(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
@@ -1060,4 +1112,446 @@ export function registerTools(server, api) {
             });
         })();
     });
+    registerCommentTools(server, api);
+}
+/**
+ * Comment tools (feat-comments §3) — stdio transport mirror of the
+ * eight HTTP MCP tools in `api/src/mcp/comment-tools.ts`. KB-page
+ * subjects return `subject_type_not_implemented` here too; the
+ * polymorphic shape is part of the public contract so the CLI's MCP
+ * surface accepts the same input even when the wire path 501s.
+ */ function registerCommentTools(server, api) {
+    function rejectKbPage() {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        error: 'subject_type_not_implemented',
+                        message: 'KB-page subjects are not yet supported. Pass subject_type="artifact".',
+                        status: 501
+                    })
+                }
+            ],
+            isError: true
+        };
+    }
+    function requireShortId(args) {
+        if (!args.short_id) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: 'validation_error',
+                            message: 'short_id is required for subject_type=artifact',
+                            status: 400
+                        })
+                    }
+                ],
+                isError: true
+            };
+        }
+        return args.short_id;
+    }
+    var subjectArgs = {
+        subject_type: z.enum([
+            'artifact',
+            'kb_page'
+        ]).describe('Subject discriminator'),
+        short_id: z.string().optional().describe('Artifact shortId (subject_type=artifact)'),
+        kb_name: z.string().optional().describe('KB name (subject_type=kb_page; not yet supported)'),
+        file_path: z.string().optional().describe('KB page path (subject_type=kb_page; not yet supported)')
+    };
+    var anchorSchema = z.object({
+        textQuote: z.object({
+            prefix: z.string(),
+            exact: z.string(),
+            suffix: z.string()
+        }),
+        cssPath: z.string(),
+        textPosition: z.object({
+            start: z.number().int(),
+            end: z.number().int()
+        }).optional()
+    }).optional();
+    server.tool('add_comment', 'Post a root comment or reply on an artifact. Root: pass `anchor` and omit `parent_id`. Reply: pass `parent_id` (the root comment id) and omit `anchor` (replies inherit the root anchor).', _object_spread_props(_object_spread({}, subjectArgs), {
+        body: z.string().min(1).max(10000).describe('Comment body (≤10k chars)'),
+        parent_id: z.string().optional().describe('Root comment id when posting a reply'),
+        anchor: anchorSchema
+    }), function(args) {
+        return _async_to_generator(function() {
+            var shortIdOrErr, result, err;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (args.subject_type === 'kb_page') {
+                            return [
+                                2,
+                                rejectKbPage()
+                            ];
+                        }
+                        shortIdOrErr = requireShortId(args);
+                        if (typeof shortIdOrErr !== 'string') {
+                            return [
+                                2,
+                                shortIdOrErr
+                            ];
+                        }
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            api.addComment(shortIdOrErr, {
+                                body: args.body,
+                                anchor: args.anchor,
+                                parentId: args.parent_id
+                            })
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        return [
+                            2,
+                            okResponse(result)
+                        ];
+                    case 3:
+                        err = _state.sent();
+                        return [
+                            2,
+                            errorResponse(err)
+                        ];
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    server.tool('list_comments', 'List comment threads on a subject. Reads from Postgres (not the KV widget cache).', _object_spread_props(_object_spread({}, subjectArgs), {
+        status: z.enum([
+            'open',
+            'resolved',
+            'all'
+        ]).optional().describe('Defaults to "open"'),
+        since: z.string().optional().describe('ISO-8601 — return only threads with activity at or after this timestamp')
+    }), function(args) {
+        return _async_to_generator(function() {
+            var shortIdOrErr, result, err;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (args.subject_type === 'kb_page') {
+                            return [
+                                2,
+                                rejectKbPage()
+                            ];
+                        }
+                        shortIdOrErr = requireShortId(args);
+                        if (typeof shortIdOrErr !== 'string') {
+                            return [
+                                2,
+                                shortIdOrErr
+                            ];
+                        }
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            api.listComments(shortIdOrErr, {
+                                status: args.status,
+                                since: args.since
+                            })
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        return [
+                            2,
+                            okResponse(result)
+                        ];
+                    case 3:
+                        err = _state.sent();
+                        return [
+                            2,
+                            errorResponse(err)
+                        ];
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    server.tool('edit_comment', 'Edit your own comment within the 5-minute author window. After 5 minutes the body is locked.', {
+        comment_id: z.string(),
+        body: z.string().min(1).max(10000)
+    }, function(args) {
+        return _async_to_generator(function() {
+            var result, err;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            2,
+                            ,
+                            3
+                        ]);
+                        return [
+                            4,
+                            api.editComment(args.comment_id, args.body)
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        return [
+                            2,
+                            okResponse(result)
+                        ];
+                    case 2:
+                        err = _state.sent();
+                        return [
+                            2,
+                            errorResponse(err)
+                        ];
+                    case 3:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    server.tool('delete_comment', 'Soft-delete a comment. Author / artifact creator / org admin. Replies remain visible; body becomes "[deleted]".', {
+        comment_id: z.string()
+    }, function(args) {
+        return _async_to_generator(function() {
+            var err;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            2,
+                            ,
+                            3
+                        ]);
+                        return [
+                            4,
+                            api.deleteComment(args.comment_id)
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2,
+                            okResponse({
+                                deleted: true
+                            })
+                        ];
+                    case 2:
+                        err = _state.sent();
+                        return [
+                            2,
+                            errorResponse(err)
+                        ];
+                    case 3:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    server.tool('resolve_thread', 'Mark a thread resolved (root comment id). Thread participant / artifact creator / org admin.', {
+        comment_id: z.string()
+    }, function(args) {
+        return _async_to_generator(function() {
+            var result, err;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            2,
+                            ,
+                            3
+                        ]);
+                        return [
+                            4,
+                            api.resolveThread(args.comment_id)
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        return [
+                            2,
+                            okResponse(result)
+                        ];
+                    case 2:
+                        err = _state.sent();
+                        return [
+                            2,
+                            errorResponse(err)
+                        ];
+                    case 3:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    server.tool('reopen_thread', 'Reopen a resolved thread. Any authenticated user with view access on the artifact.', {
+        comment_id: z.string()
+    }, function(args) {
+        return _async_to_generator(function() {
+            var result, err;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        _state.trys.push([
+                            0,
+                            2,
+                            ,
+                            3
+                        ]);
+                        return [
+                            4,
+                            api.reopenThread(args.comment_id)
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        return [
+                            2,
+                            okResponse(result)
+                        ];
+                    case 2:
+                        err = _state.sent();
+                        return [
+                            2,
+                            errorResponse(err)
+                        ];
+                    case 3:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    server.tool('watch', 'Watch the subject for comment notifications. Per-user; service-account API keys cannot subscribe.', subjectArgs, function(args) {
+        return _async_to_generator(function() {
+            var shortIdOrErr, result, err;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (args.subject_type === 'kb_page') {
+                            return [
+                                2,
+                                rejectKbPage()
+                            ];
+                        }
+                        shortIdOrErr = requireShortId(args);
+                        if (typeof shortIdOrErr !== 'string') {
+                            return [
+                                2,
+                                shortIdOrErr
+                            ];
+                        }
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            api.watchArtifact(shortIdOrErr)
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        return [
+                            2,
+                            okResponse(result)
+                        ];
+                    case 3:
+                        err = _state.sent();
+                        return [
+                            2,
+                            errorResponse(err)
+                        ];
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
+    server.tool('unwatch', 'Unwatch the subject. Per-user; service-account API keys cannot subscribe.', subjectArgs, function(args) {
+        return _async_to_generator(function() {
+            var shortIdOrErr, err;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (args.subject_type === 'kb_page') {
+                            return [
+                                2,
+                                rejectKbPage()
+                            ];
+                        }
+                        shortIdOrErr = requireShortId(args);
+                        if (typeof shortIdOrErr !== 'string') {
+                            return [
+                                2,
+                                shortIdOrErr
+                            ];
+                        }
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            api.unwatchArtifact(shortIdOrErr)
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            2,
+                            okResponse({
+                                watching: false
+                            })
+                        ];
+                    case 3:
+                        err = _state.sent();
+                        return [
+                            2,
+                            errorResponse(err)
+                        ];
+                    case 4:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    });
 }

package/package.json

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