@displaydev/cli 0.17.0 → 0.19.0

package/dist/mcp-server.js

@@ -63,39 +63,27 @@ function _object_spread(target) {
     }
     return target;
 }
-function _object_without_properties(source, excluded) {
-    if (source == null) return {};
-    var target = {}, sourceKeys, key, i;
-    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
-        sourceKeys = Reflect.ownKeys(Object(source));
-        for(i = 0; i < sourceKeys.length; i++){
-            key = sourceKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
-        }
-        return target;
-    }
-    target = _object_without_properties_loose(source, excluded);
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
-        sourceKeys = Object.getOwnPropertySymbols(source);
-        for(i = 0; i < sourceKeys.length; i++){
-            key = sourceKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
         }
+        keys.push.apply(keys, symbols);
     }
-    return target;
+    return keys;
 }
-function _object_without_properties_loose(source, excluded) {
-    if (source == null) return {};
-    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
-    for(i = 0; i < sourceKeys.length; i++){
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-        target[key] = source[key];
+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;
 }
@@ -624,24 +612,29 @@ export function registerTools(server, api) {
             });
         })();
     });
-    server.tool('find', 'Search for artifacts in the organization', {
-        query: z.string().optional().describe('Search by artifact name'),
-        published_by: z.string().optional().describe('Filter by publisher email'),
-        mine: z.boolean().optional().describe('Limit results to your own artifacts'),
-        since: z.string().optional().describe('Filter by updated since ISO date'),
+    server.tool('find', 'List or search artifacts in the caller\'s organization. Omit `query` to list every artifact (paginated). Filter by name, one-or-more authors, one-or-more visibilities, or update time. Sort by `updated_at` (default), `view_count`, or `name`. Paginate via `cursor` — if the result includes a non-null `nextCursor`, pass it back to fetch the next page; if filters change between calls, drop the cursor. The response also carries `totalCount` (`-1` means the count query exceeded its budget — treat as "many"). `visibility: ["private"]` returns only your own private artifacts, not org-wide.', {
+        query: z.string().optional().describe('Search by artifact name (case-insensitive substring). Omit to list all artifacts.'),
+        author: z.array(z.string()).optional().describe('Filter by one or more authors. Each value: email, userId, or the literal "me". Multiple values are ORed. "me" requires a user-scoped credential — with an org API key the wire drops it.'),
+        visibility: z.array(z.enum([
+            'public',
+            'company',
+            'private'
+        ])).optional().describe('Filter by one or more visibility levels. NOTE: "private" is creator-scoped — only your own private artifacts are returned, not org-wide.'),
+        since: z.string().optional().describe('ISO timestamp; only artifacts updated on or after this point.'),
         sort: z.enum([
             'updated_at',
             'view_count',
             'name'
-        ]).optional().describe('Sort column'),
+        ]).optional().describe('Sort column. Defaults to updated_at.'),
         dir: z.enum([
             'asc',
             'desc'
-        ]).optional().describe('Sort direction'),
-        limit: z.number().optional().describe('Max results to return (1-100)')
+        ]).optional().describe('Sort direction. Defaults: desc for updated_at and view_count, asc for name.'),
+        cursor: z.string().optional().describe('Opaque pagination token from a prior response. Pass it back to fetch the next page. WARNING: only valid for the same `sort`/`dir`/filter set that issued it — change a filter and drop the cursor, or results will be skewed without an error.'),
+        limit: z.number().int().min(1).max(100).optional().describe('Max results per page (1–100, default 50).')
     }, function(args) {
         return _async_to_generator(function() {
-            var publishedBy, rest, results, err;
+            var result, err;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
@@ -651,25 +644,15 @@ export function registerTools(server, api) {
                             ,
                             3
                         ]);
-                        // Translate the snake_case MCP arg to the camelCase wire shape that
-                        // ApiClient.find() forwards to GET /v1/artifacts. MCP convention
-                        // prefers snake_case in tool schemas; the wire is camelCase
-                        // (api-conventions §1.2). Without this map, `published_by` was
-                        // silently dropped on the floor and the filter went unfiltered.
-                        publishedBy = args.published_by, rest = _object_without_properties(args, [
-                            "published_by"
-                        ]);
                         return [
                             4,
-                            api.find(_object_spread({}, rest, publishedBy !== undefined ? {
-                                publishedBy: publishedBy
-                            } : {}))
+                            api.find(args)
                         ];
                     case 1:
-                        results = _state.sent();
+                        result = _state.sent();
                         return [
                             2,
-                            okResponse(results)
+                            okResponse(result)
                         ];
                     case 2:
                         err = _state.sent();
@@ -1129,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.17.0",
+  "version": "0.19.0",
   "type": "module",
   "bin": {
     "dsp": "dist/main.js"