@orboto/mcp 0.178.0

package/dist/tools/doc-attachments.test.js

@@ -0,0 +1,136 @@
+/**
+ * ORB-914 - doc-attachments tool tests.
+ *
+ * Multipart upload's wire format is opaque to JSON inspection - we
+ * just assert URL + method + that the FormData carries a `file` field.
+ * The embed branch is covered by checking that a follow-up PATCH lands
+ * on /docs/:id with the appended Markdown line.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { OrbotoClient } from '../orboto-client.js';
+import { makeUploadDocAttachmentHandler, makeListDocAttachmentsHandler, makeDeleteDocAttachmentHandler, } from './doc-attachments.js';
+beforeEach(() => { vi.restoreAllMocks(); });
+afterEach(() => { vi.restoreAllMocks(); });
+const client = new OrbotoClient({ baseUrl: 'https://orboto.example.com', apiKey: 'orb_x' });
+const DOC_ID = 'd0000000-0000-0000-0000-000000000001';
+const ATT_ID = 'a0000000-0000-0000-0000-000000000001';
+const ATTACHMENT = {
+    id: ATT_ID,
+    targetType: 'doc',
+    targetId: DOC_ID,
+    filename: 'arch.png',
+    contentType: 'image/png',
+    sizeBytes: 4096,
+    uploadedBy: 'u1',
+    uploadedAt: '2026-05-17T13:30:00.000Z',
+    downloadUrl: `/attachments/${ATT_ID}`,
+};
+function stubFetch(responses) {
+    const calls = [];
+    vi.spyOn(globalThis, 'fetch').mockImplementation(async (url, init) => {
+        calls.push({
+            url: url.toString(),
+            method: init?.method ?? 'GET',
+            body: init?.body,
+        });
+        const r = responses.shift();
+        if (!r)
+            throw new Error('unexpected extra fetch');
+        return {
+            ok: r.ok ?? true,
+            status: r.status ?? 200,
+            statusText: 'OK',
+            json: async () => ('json' in r ? r.json : {}),
+            text: async () => '',
+        };
+    });
+    return calls;
+}
+const TINY_PNG_BASE64 = 
+// 1x1 red png - smallest valid bytes we can pass through
+'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAFhAJ/wlseKgAAAABJRU5ErkJggg==';
+describe('orboto_upload_doc_attachment', () => {
+    it('POSTs multipart to /docs/:id/attachments and returns markdown image line', async () => {
+        const calls = stubFetch([{ status: 201, json: ATTACHMENT }]);
+        const res = await makeUploadDocAttachmentHandler(client)({
+            docId: DOC_ID,
+            filename: 'arch.png',
+            contentBase64: TINY_PNG_BASE64,
+        });
+        expect(calls[0]).toMatchObject({
+            method: 'POST',
+            url: `https://orboto.example.com/docs/${DOC_ID}/attachments`,
+        });
+        // FormData reaches fetch as a FormData instance.
+        expect(calls[0].body).toBeInstanceOf(FormData);
+        const fd = calls[0].body;
+        expect(fd.get('file')).toBeTruthy();
+        expect(res.structuredContent).toMatchObject({
+            attachmentId: ATT_ID,
+            filename: 'arch.png',
+            downloadUrl: `/attachments/${ATT_ID}`,
+            markdown: `![arch.png](/attachments/${ATT_ID})`,
+            embedded: false,
+        });
+    });
+    it('embeds the markdown line into the doc body when embed=true', async () => {
+        const calls = stubFetch([
+            { status: 201, json: ATTACHMENT },
+            { json: { id: DOC_ID, spaceId: 's1', parentDocId: null, title: 'Arch', content: '# Header\n\nbody', slug: 'arch', visibility: 'workspace', icon: null, sortOrder: 0, updatedAt: '2026-05-17T13:30:00.000Z' } },
+            { json: { id: DOC_ID, content: '# Header\n\nbody\n\n![arch.png](/attachments/' + ATT_ID + ')' } },
+        ]);
+        await makeUploadDocAttachmentHandler(client)({
+            docId: DOC_ID,
+            filename: 'arch.png',
+            contentBase64: TINY_PNG_BASE64,
+            embed: true,
+        });
+        expect(calls[1]).toMatchObject({ method: 'GET', url: `https://orboto.example.com/docs/${DOC_ID}` });
+        expect(calls[2]).toMatchObject({ method: 'PATCH', url: `https://orboto.example.com/docs/${DOC_ID}` });
+        const patchBody = JSON.parse(calls[2].body);
+        expect(patchBody.content).toContain(`![arch.png](/attachments/${ATT_ID})`);
+        expect(patchBody.content).toContain('# Header');
+    });
+    it('refuses an empty-bytes upload before hitting the API', async () => {
+        const calls = stubFetch([]);
+        await expect(makeUploadDocAttachmentHandler(client)({ docId: DOC_ID, filename: 'empty.png', contentBase64: '' })).rejects.toThrow();
+        expect(calls).toHaveLength(0);
+    });
+    it('uses link syntax (not image) for non-image MIME types', async () => {
+        stubFetch([{ status: 201, json: { ...ATTACHMENT, filename: 'spec.pdf', contentType: 'application/pdf' } }]);
+        const res = await makeUploadDocAttachmentHandler(client)({
+            docId: DOC_ID,
+            filename: 'spec.pdf',
+            contentBase64: TINY_PNG_BASE64,
+        });
+        expect(res.structuredContent).toMatchObject({
+            markdown: `[spec.pdf](/attachments/${ATT_ID})`,
+        });
+    });
+});
+describe('orboto_list_doc_attachments', () => {
+    it('renders one line per attachment with KB + URL', async () => {
+        const calls = stubFetch([{ json: [ATTACHMENT] }]);
+        const res = await makeListDocAttachmentsHandler(client)({ docId: DOC_ID });
+        expect(calls[0]).toMatchObject({ method: 'GET', url: `https://orboto.example.com/docs/${DOC_ID}/attachments` });
+        expect(res.content[0].text).toContain('arch.png');
+        expect(res.content[0].text).toContain('4 KB');
+    });
+    it('reports the empty-list case explicitly', async () => {
+        stubFetch([{ json: [] }]);
+        const res = await makeListDocAttachmentsHandler(client)({ docId: DOC_ID });
+        expect(res.content[0].text).toContain('No attachments');
+        expect(res.structuredContent).toMatchObject({ attachments: [] });
+    });
+});
+describe('orboto_delete_doc_attachment', () => {
+    it('DELETEs /docs/:id/attachments/:attId', async () => {
+        const calls = stubFetch([{ status: 204, json: undefined }]);
+        const res = await makeDeleteDocAttachmentHandler(client)({ docId: DOC_ID, attachmentId: ATT_ID });
+        expect(calls[0]).toMatchObject({
+            method: 'DELETE',
+            url: `https://orboto.example.com/docs/${DOC_ID}/attachments/${ATT_ID}`,
+        });
+        expect(res.structuredContent).toMatchObject({ deleted: true });
+    });
+});

package/dist/tools/doc-comments.js

@@ -0,0 +1,228 @@
+/**
+ * ORB-917 - doc-comments MCP tools (epic ORB-911 Phase 6).
+ *
+ * - orboto_list_doc_comments - GET /docs/:id/comments  (cursor-paged, oldest-first)
+ * - orboto_post_doc_comment - POST /docs/:id/comments
+ * - orboto_resolve_doc_comment - POST /docs/:id/comments/:cid/resolve
+ * - orboto_delete_doc_comment - DELETE /docs/:id/comments/:cid
+ *
+ * Comments support replies (single-level - replying to a reply lands as
+ * a sibling of the original reply because the API auto-flattens past
+ * one level) and optional anchors (a 3-tuple of {text, before, after}
+ * the frontend uses to re-locate a highlight even after the doc body
+ * has shifted).
+ *
+ * resolve acts on the thread root by design so resolving from a reply
+ * folds the whole conversation - mirrors the web UI's behaviour.
+ */
+import { z } from 'zod';
+import { resolveDocId } from './docs.js';
+// ---------------------------------------------------------------------------
+// orboto_list_doc_comments
+// ---------------------------------------------------------------------------
+export const listDocCommentsToolConfig = {
+    title: 'List comments on a doc page',
+    description: 'Return comments on a doc page, oldest-first so the reply tree reads top-to-bottom. Each row carries the author name + content + resolved state. Cursor-paged - pass `cursor` from the previous call\'s nextCursor to walk older pages.',
+    inputSchema: z.object({
+        docId: z.string().min(1).describe('Doc UUID or human-readable doc key (ORB-D12 / DOC-5).'),
+        limit: z.number().int().min(1).max(100).optional(),
+        cursor: z.string().optional(),
+    }).shape,
+    annotations: { readOnlyHint: true, idempotentHint: true },
+};
+export function makeListDocCommentsHandler(client) {
+    return async ({ docId, limit, cursor }) => {
+        docId = await resolveDocId(client, docId);
+        const qs = new URLSearchParams();
+        if (limit !== undefined)
+            qs.set('limit', String(limit));
+        if (cursor)
+            qs.set('cursor', cursor);
+        const query = qs.toString();
+        const page = await client.get(`/docs/${docId}/comments${query ? `?${query}` : ''}`);
+        if (page.items.length === 0) {
+            return {
+                content: [{ type: 'text', text: 'No comments on this doc.' }],
+                structuredContent: { comments: [], nextCursor: null },
+            };
+        }
+        // Build a parent-keyed tree so the Markdown rendering can indent
+        // replies one level under their root. The API already flattens
+        // past one level, so depth is always 0 or 1.
+        const byParent = new Map();
+        for (const c of page.items) {
+            const key = c.parentCommentId ?? null;
+            const arr = byParent.get(key) ?? [];
+            arr.push(c);
+            byParent.set(key, arr);
+        }
+        const lines = [];
+        const renderOne = (c, depth) => {
+            const indent = '  '.repeat(depth);
+            const author = c.userName ?? `user ${c.userId.slice(0, 8)}`;
+            const resolved = c.resolvedAt ? ' [resolved]' : '';
+            lines.push(`${indent}- ${author}  ·  ${c.createdAt}${resolved}  ·  id: ${c.id}`);
+            // Anchor preview helps the model understand what part of the
+            // doc the comment is anchored to. Truncate to keep the output
+            // compact.
+            if (c.anchor) {
+                const snippet = c.anchor.text.length > 80 ? c.anchor.text.slice(0, 77) + '...' : c.anchor.text;
+                lines.push(`${indent}  anchored on: "${snippet}"`);
+            }
+            const body = c.content.split('\n').map((l) => `${indent}  ${l}`).join('\n');
+            lines.push(body);
+            // Render direct replies one level deeper.
+            const replies = byParent.get(c.id) ?? [];
+            for (const r of replies)
+                renderOne(r, depth + 1);
+        };
+        for (const root of byParent.get(null) ?? []) {
+            renderOne(root, 0);
+            lines.push(''); // blank line between root threads
+        }
+        if (page.nextCursor) {
+            lines.push(`(more available - pass cursor: ${page.nextCursor})`);
+        }
+        return {
+            content: [{ type: 'text', text: lines.join('\n').trimEnd() }],
+            structuredContent: {
+                comments: page.items.map((c) => ({
+                    id: c.id,
+                    docId: c.docId,
+                    userId: c.userId,
+                    userName: c.userName,
+                    parentCommentId: c.parentCommentId,
+                    content: c.content,
+                    anchor: c.anchor,
+                    resolvedAt: c.resolvedAt,
+                    resolvedBy: c.resolvedBy,
+                    resolvedByName: c.resolvedByName,
+                    createdAt: c.createdAt,
+                })),
+                nextCursor: page.nextCursor,
+            },
+        };
+    };
+}
+// ---------------------------------------------------------------------------
+// orboto_post_doc_comment
+// ---------------------------------------------------------------------------
+export const postDocCommentToolConfig = {
+    title: 'Post a comment on a doc page (or reply to one)',
+    description: 'Add a comment to a doc page. Pass `parentCommentId` to reply (the API flattens reply chains past one level so a reply-of-reply lands as a sibling of the original reply). Optional `anchor` (`{text, before, after}`) attaches the comment to a specific highlight in the body - the frontend uses the surrounding context to re-locate the anchor even after the doc has been edited. Mentions in the content body (`@username`) fire notifications automatically.',
+    inputSchema: z.object({
+        docId: z.string().min(1).describe('Doc UUID or human-readable doc key (ORB-D12 / DOC-5).'),
+        content: z.string().min(1).max(4000),
+        parentCommentId: z.string().uuid().optional().describe('Reply to an existing comment.'),
+        anchor: z.object({
+            text: z.string().min(1).max(400).describe('The highlighted body text the comment is anchored to.'),
+            before: z.string().max(80).describe('Characters before the highlight, for anchor re-discovery.'),
+            after: z.string().max(80).describe('Characters after the highlight, for anchor re-discovery.'),
+        }).optional(),
+    }).shape,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+};
+export function makePostDocCommentHandler(client) {
+    return async ({ docId, content, parentCommentId, anchor }) => {
+        docId = await resolveDocId(client, docId);
+        const body = { content };
+        if (parentCommentId)
+            body.parentCommentId = parentCommentId;
+        if (anchor)
+            body.anchor = anchor;
+        const row = await client.post(`/docs/${docId}/comments`, body);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Posted comment ${row.id} on doc ${docId}${row.parentCommentId ? ` (reply to ${row.parentCommentId})` : ''}.`,
+                }],
+            structuredContent: {
+                id: row.id,
+                docId: row.docId,
+                parentCommentId: row.parentCommentId,
+                content: row.content,
+                anchor: row.anchor,
+                createdAt: row.createdAt,
+            },
+        };
+    };
+}
+// ---------------------------------------------------------------------------
+// orboto_resolve_doc_comment
+// ---------------------------------------------------------------------------
+export const resolveDocCommentToolConfig = {
+    title: 'Mark a doc comment thread as resolved (or reopen it)',
+    description: 'Toggle a comment thread\'s resolved state. Pass `resolved=true` to fold the conversation, `resolved=false` to reopen. Always acts on the thread ROOT - resolving from a reply folds the whole conversation, same as the web UI.',
+    inputSchema: z.object({
+        docId: z.string().min(1).describe('Doc UUID or human-readable doc key (ORB-D12 / DOC-5).'),
+        commentId: z.string().uuid(),
+        resolved: z.boolean(),
+    }).shape,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+};
+export function makeResolveDocCommentHandler(client) {
+    return async ({ docId, commentId, resolved }) => {
+        docId = await resolveDocId(client, docId);
+        const row = await client.post(`/docs/${docId}/comments/${commentId}/resolve`, { resolved });
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Comment thread ${row.id} ${resolved ? 'resolved' : 'reopened'}.`,
+                }],
+            structuredContent: {
+                id: row.id,
+                resolvedAt: row.resolvedAt,
+                resolvedBy: row.resolvedBy,
+            },
+        };
+    };
+}
+// ---------------------------------------------------------------------------
+// orboto_update_doc_comment - ORB-933
+// ---------------------------------------------------------------------------
+export const updateDocCommentToolConfig = {
+    title: 'Edit your own doc comment',
+    description: 'Edit a doc comment\'s body. Author OR super-admin can edit; everyone else gets a 403. Doc-comments do not carry a revision history today (unlike ticket comments), so the prior content is overwritten in place. A no-op call (same content as before) returns the unchanged row.',
+    inputSchema: z.object({
+        docId: z.string().min(1).describe('Doc UUID or human-readable doc key (ORB-D12 / DOC-5).'),
+        commentId: z.string().uuid(),
+        content: z.string().min(1).max(4000),
+    }).shape,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true },
+};
+export function makeUpdateDocCommentHandler(client) {
+    return async ({ docId, commentId, content }) => {
+        docId = await resolveDocId(client, docId);
+        const row = await client.patch(`/docs/${docId}/comments/${commentId}`, { content });
+        return {
+            content: [{ type: 'text', text: `Doc comment ${row.id} updated.` }],
+            structuredContent: {
+                id: row.id,
+                docId: row.docId,
+                content: row.content,
+            },
+        };
+    };
+}
+// ---------------------------------------------------------------------------
+// orboto_delete_doc_comment
+// ---------------------------------------------------------------------------
+export const deleteDocCommentToolConfig = {
+    title: 'Delete a doc comment',
+    description: 'DESTRUCTIVE - drops the comment + (via FK cascade) every reply under it. Only the author can delete their own comments; super-admins can delete anyone\'s. Returns success silently; 403 surfaces as an OrbotoApiError.',
+    inputSchema: z.object({
+        docId: z.string().min(1).describe('Doc UUID or human-readable doc key (ORB-D12 / DOC-5).'),
+        commentId: z.string().uuid(),
+    }).shape,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
+};
+export function makeDeleteDocCommentHandler(client) {
+    return async ({ docId, commentId }) => {
+        docId = await resolveDocId(client, docId);
+        await client.delete(`/docs/${docId}/comments/${commentId}`);
+        return {
+            content: [{ type: 'text', text: `Comment ${commentId} deleted from doc ${docId}.` }],
+            structuredContent: { docId, commentId, deleted: true },
+        };
+    };
+}

package/dist/tools/doc-comments.test.js

@@ -0,0 +1,192 @@
+/**
+ * ORB-917 - doc-comments tool tests.
+ *
+ *   - list: happy + tree-render + empty + nextCursor
+ *   - post: happy + reply (parentCommentId) + anchor passthrough
+ *   - resolve: true + false toggle
+ *   - delete: happy + 403 ownership bubble
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { OrbotoApiError, OrbotoClient } from '../orboto-client.js';
+import { makeListDocCommentsHandler, makePostDocCommentHandler, makeResolveDocCommentHandler, makeUpdateDocCommentHandler, makeDeleteDocCommentHandler, } from './doc-comments.js';
+beforeEach(() => { vi.restoreAllMocks(); });
+afterEach(() => { vi.restoreAllMocks(); });
+const client = new OrbotoClient({ baseUrl: 'https://orboto.example.com', apiKey: 'orb_x' });
+const DOC_ID = 'd0000000-0000-0000-0000-000000000001';
+const COMMENT_ID = 'c0000000-0000-0000-0000-000000000001';
+function stubJSON(responses) {
+    const calls = [];
+    vi.spyOn(globalThis, 'fetch').mockImplementation(async (url, init) => {
+        calls.push({
+            url: url.toString(),
+            method: init?.method ?? 'GET',
+            body: typeof init?.body === 'string' ? JSON.parse(init.body) : init?.body,
+        });
+        const r = responses.shift();
+        if (!r)
+            throw new Error('unexpected extra fetch');
+        return {
+            ok: r.ok ?? true,
+            status: r.status ?? 200,
+            statusText: 'OK',
+            json: async () => ('json' in r ? r.json : {}),
+            text: async () => '',
+        };
+    });
+    return calls;
+}
+const ROOT_COMMENT = {
+    id: COMMENT_ID,
+    docId: DOC_ID,
+    userId: 'u1',
+    userName: 'Alice',
+    parentCommentId: null,
+    content: 'Looks good to me.',
+    anchor: null,
+    resolvedAt: null,
+    resolvedBy: null,
+    createdAt: '2026-05-17T12:00:00.000Z',
+};
+const REPLY_COMMENT = {
+    ...ROOT_COMMENT,
+    id: 'c0000000-0000-0000-0000-000000000002',
+    userId: 'u2',
+    userName: 'Bob',
+    parentCommentId: ROOT_COMMENT.id,
+    content: 'Agreed.',
+    createdAt: '2026-05-17T12:05:00.000Z',
+};
+describe('orboto_list_doc_comments', () => {
+    it('renders an indented tree with root + replies', async () => {
+        stubJSON([{ json: { items: [ROOT_COMMENT, REPLY_COMMENT], nextCursor: null } }]);
+        const res = await makeListDocCommentsHandler(client)({ docId: DOC_ID });
+        const text = res.content[0].text;
+        expect(text.indexOf('Alice')).toBeLessThan(text.indexOf('Bob'));
+        expect(text).toMatch(/\s\s- Bob/); // reply is indented one level
+        expect(text).toContain('Agreed.');
+        const comments = res.structuredContent.comments;
+        expect(comments).toHaveLength(2);
+    });
+    it('reports the empty-comments case', async () => {
+        stubJSON([{ json: { items: [], nextCursor: null } }]);
+        const res = await makeListDocCommentsHandler(client)({ docId: DOC_ID });
+        expect(res.content[0].text).toContain('No comments');
+    });
+    it('surfaces nextCursor in both the structured payload and the text', async () => {
+        stubJSON([{ json: { items: [ROOT_COMMENT], nextCursor: 'NEXT' } }]);
+        const res = await makeListDocCommentsHandler(client)({ docId: DOC_ID });
+        expect(res.content[0].text).toContain('NEXT');
+        expect(res.structuredContent).toMatchObject({ nextCursor: 'NEXT' });
+    });
+    it('surfaces the anchor preview when a comment is anchored', async () => {
+        const anchored = {
+            ...ROOT_COMMENT,
+            anchor: { text: 'retry backoff is 200ms', before: 'The ', after: '. Reset' },
+        };
+        stubJSON([{ json: { items: [anchored], nextCursor: null } }]);
+        const res = await makeListDocCommentsHandler(client)({ docId: DOC_ID });
+        expect(res.content[0].text).toContain('anchored on: "retry backoff is 200ms"');
+    });
+});
+describe('orboto_post_doc_comment', () => {
+    it('POSTs content with no parent for a root comment', async () => {
+        const calls = stubJSON([{ status: 201, json: ROOT_COMMENT }]);
+        await makePostDocCommentHandler(client)({
+            docId: DOC_ID,
+            content: 'Looks good to me.',
+        });
+        expect(calls[0]).toMatchObject({
+            method: 'POST',
+            url: `https://orboto.example.com/docs/${DOC_ID}/comments`,
+            body: { content: 'Looks good to me.' },
+        });
+        // No parentCommentId in the body for a root comment.
+        expect(calls[0].body.parentCommentId).toBeUndefined();
+    });
+    it('passes parentCommentId through for a reply', async () => {
+        const calls = stubJSON([{ status: 201, json: REPLY_COMMENT }]);
+        await makePostDocCommentHandler(client)({
+            docId: DOC_ID,
+            content: 'Agreed.',
+            parentCommentId: ROOT_COMMENT.id,
+        });
+        expect(calls[0].body).toMatchObject({
+            content: 'Agreed.',
+            parentCommentId: ROOT_COMMENT.id,
+        });
+    });
+    it('passes anchor through for an anchored comment', async () => {
+        const calls = stubJSON([{ status: 201, json: ROOT_COMMENT }]);
+        await makePostDocCommentHandler(client)({
+            docId: DOC_ID,
+            content: 'This needs clarification.',
+            anchor: { text: 'API key required', before: 'The ', after: '.' },
+        });
+        expect(calls[0].body.anchor).toMatchObject({
+            text: 'API key required',
+            before: 'The ',
+            after: '.',
+        });
+    });
+});
+describe('orboto_resolve_doc_comment', () => {
+    it('POSTs resolved=true on resolve', async () => {
+        const calls = stubJSON([{ json: { ...ROOT_COMMENT, resolvedAt: '2026-05-17T13:00:00.000Z', resolvedBy: 'u1' } }]);
+        const res = await makeResolveDocCommentHandler(client)({
+            docId: DOC_ID,
+            commentId: COMMENT_ID,
+            resolved: true,
+        });
+        expect(calls[0]).toMatchObject({
+            method: 'POST',
+            url: `https://orboto.example.com/docs/${DOC_ID}/comments/${COMMENT_ID}/resolve`,
+            body: { resolved: true },
+        });
+        expect(res.content[0].text).toContain('resolved');
+    });
+    it('POSTs resolved=false on reopen', async () => {
+        const calls = stubJSON([{ json: { ...ROOT_COMMENT, resolvedAt: null, resolvedBy: null } }]);
+        const res = await makeResolveDocCommentHandler(client)({
+            docId: DOC_ID,
+            commentId: COMMENT_ID,
+            resolved: false,
+        });
+        expect(calls[0].body).toMatchObject({ resolved: false });
+        expect(res.content[0].text).toContain('reopened');
+    });
+});
+describe('orboto_delete_doc_comment', () => {
+    it('DELETEs the comment id', async () => {
+        const calls = stubJSON([{ status: 204, json: undefined }]);
+        const res = await makeDeleteDocCommentHandler(client)({ docId: DOC_ID, commentId: COMMENT_ID });
+        expect(calls[0]).toMatchObject({
+            method: 'DELETE',
+            url: `https://orboto.example.com/docs/${DOC_ID}/comments/${COMMENT_ID}`,
+        });
+        expect(res.structuredContent).toMatchObject({ deleted: true });
+    });
+    it('bubbles up a 403 when deleting someone else\'s comment', async () => {
+        stubJSON([{ ok: false, status: 403, json: { error: 'Forbidden' } }]);
+        await expect(makeDeleteDocCommentHandler(client)({ docId: DOC_ID, commentId: COMMENT_ID })).rejects.toBeInstanceOf(OrbotoApiError);
+    });
+});
+describe('orboto_update_doc_comment', () => {
+    it('PATCHes content on the comment id', async () => {
+        const calls = stubJSON([{ json: { ...ROOT_COMMENT, content: 'Updated.' } }]);
+        const res = await makeUpdateDocCommentHandler(client)({
+            docId: DOC_ID,
+            commentId: COMMENT_ID,
+            content: 'Updated.',
+        });
+        expect(calls[0]).toMatchObject({
+            method: 'PATCH',
+            url: `https://orboto.example.com/docs/${DOC_ID}/comments/${COMMENT_ID}`,
+            body: { content: 'Updated.' },
+        });
+        expect(res.structuredContent.content).toBe('Updated.');
+    });
+    it('bubbles up a 403 when editing someone else\'s comment', async () => {
+        stubJSON([{ ok: false, status: 403, json: { error: 'Forbidden - only the author can edit this comment' } }]);
+        await expect(makeUpdateDocCommentHandler(client)({ docId: DOC_ID, commentId: COMMENT_ID, content: 'X' })).rejects.toBeInstanceOf(OrbotoApiError);
+    });
+});