@orboto/mcp 0.178.0

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

@@ -0,0 +1,106 @@
+/**
+ * ORB-1455 - orboto_list_ticket_attachments + orboto_get_attachment tests.
+ *
+ * list: resolves the ticket by key, GETs /tickets/:id/attachments, renders
+ *       one metadata line per attachment (empty-list case too).
+ * get:  fetches the base64 route and returns an IMAGE content block for a png,
+ *       a TEXT block for a pdf, and a size-cap refusal (skill-download pointer)
+ *       for an over-limit file.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { OrbotoClient } from '../orboto-client.js';
+import { makeListTicketAttachmentsHandler, makeGetAttachmentHandler } from './ticket-attachments.js';
+beforeEach(() => { vi.restoreAllMocks(); });
+afterEach(() => { vi.restoreAllMocks(); });
+const client = new OrbotoClient({ baseUrl: 'https://orboto.example.com', apiKey: 'orb_x' });
+const PROJ = { id: 'p1', key: 'ACME', name: 'Acme', description: null, status: 'active' };
+const TICKET = {
+    id: 't1', projectId: 'p1', ticketKey: 'ACME-1', ticketNumber: 1,
+    title: 'Bug', description: 'body', status: 'TODO', statusName: 'To Do',
+    statusCategory: 'todo', type: 'bug', priority: 'normal',
+    estimatedTimeMinutes: 0, dueDate: null, isPrivate: false,
+};
+const ATT_ID = 'a0000000-0000-0000-0000-000000000001';
+const PNG_ATTACHMENT = {
+    id: ATT_ID, targetType: 'ticket', targetId: 't1',
+    filename: 'screenshot.png', contentType: 'image/png', sizeBytes: 4096,
+    uploadedBy: 'u1', uploadedAt: '2026-07-09T13: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' });
+        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 = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAFhAJ/wlseKgAAAABJRU5ErkJggg==';
+describe('orboto_list_ticket_attachments', () => {
+    it('resolves the ticket and lists its attachments with KB + id + URL', async () => {
+        const calls = stubFetch([
+            { json: PROJ }, // resolveTicketByKey: project
+            { json: TICKET }, // resolveTicketByKey: ticket
+            { json: [PNG_ATTACHMENT] }, // GET /tickets/:id/attachments
+        ]);
+        const res = await makeListTicketAttachmentsHandler(client)({ ticketKey: 'ACME-1' });
+        expect(calls[2]).toMatchObject({ method: 'GET', url: 'https://orboto.example.com/tickets/t1/attachments' });
+        const text = res.content[0].text;
+        expect(text).toContain('screenshot.png');
+        expect(text).toContain('4 KB');
+        expect(text).toContain(ATT_ID);
+        expect(res.structuredContent).toMatchObject({
+            ticketKey: 'ACME-1',
+            attachments: [{ id: ATT_ID, filename: 'screenshot.png', contentType: 'image/png', sizeBytes: 4096 }],
+        });
+    });
+    it('reports the empty-list case explicitly', async () => {
+        stubFetch([{ json: PROJ }, { json: TICKET }, { json: [] }]);
+        const res = await makeListTicketAttachmentsHandler(client)({ ticketKey: 'ACME-1' });
+        expect(res.content[0].text).toContain('No attachments');
+        expect(res.structuredContent).toMatchObject({ attachments: [] });
+    });
+});
+describe('orboto_get_attachment', () => {
+    it('returns an image content block for a png', async () => {
+        const calls = stubFetch([{
+                json: { id: ATT_ID, filename: 'screenshot.png', contentType: 'image/png', sizeBytes: 4096, contentBase64: TINY_PNG_BASE64 },
+            }]);
+        const res = await makeGetAttachmentHandler(client)({ attachmentId: ATT_ID });
+        expect(calls[0]).toMatchObject({ method: 'GET', url: `https://orboto.example.com/attachments/${ATT_ID}/base64` });
+        const img = res.content.find((c) => c.type === 'image');
+        expect(img).toBeTruthy();
+        expect(img.data).toBe(TINY_PNG_BASE64);
+        expect(img.mimeType).toBe('image/png');
+        expect(res.structuredContent).toMatchObject({ id: ATT_ID, inlined: true });
+    });
+    it('returns a text block (no image) for a pdf', async () => {
+        stubFetch([{
+                json: { id: ATT_ID, filename: 'spec.pdf', contentType: 'application/pdf', sizeBytes: 2048, contentBase64: TINY_PNG_BASE64 },
+            }]);
+        const res = await makeGetAttachmentHandler(client)({ attachmentId: ATT_ID });
+        expect(res.content.find((c) => c.type === 'image')).toBeUndefined();
+        const text = res.content[0].text;
+        expect(text).toContain('spec.pdf');
+        expect(text).toContain('application/pdf');
+        expect(res.structuredContent).toMatchObject({ inlined: true, contentType: 'application/pdf' });
+    });
+    it('refuses an over-limit file inline and points at the skill download', async () => {
+        stubFetch([{
+                json: { id: ATT_ID, filename: 'huge.png', contentType: 'image/png', sizeBytes: 8 * 1024 * 1024, contentBase64: TINY_PNG_BASE64 },
+            }]);
+        const res = await makeGetAttachmentHandler(client)({ attachmentId: ATT_ID });
+        expect(res.content.find((c) => c.type === 'image')).toBeUndefined();
+        const text = res.content[0].text;
+        expect(text).toContain('download-attachment');
+        expect(res.structuredContent).toMatchObject({ inlined: false });
+    });
+});

package/dist/tools/ticket-schedules.js

@@ -0,0 +1,112 @@
+/**
+ * ORB-626 - ticket meeting-schedule tools.
+ *
+ * Wrap the /tickets/:id/schedules endpoints:
+ *   - orboto_list_ticket_schedules  - list a ticket's working sessions.
+ *   - orboto_schedule_ticket_session - schedule a working session (drops a
+ *     plan-block on every orboto attendee + sends an iCal invite).
+ *   - orboto_cancel_ticket_session  - cancel a scheduled session (removes
+ *     the plan-blocks + sends an iCal cancellation).
+ */
+import { z } from 'zod';
+import { resolveTicketByKey } from './shared.js';
+function scheduleLine(s) {
+    const when = `${s.startsAt} -> ${s.endsAt}`;
+    const people = s.attendees.length + s.externalAttendees.length;
+    const state = s.cancelledAt ? ' [CANCELLED]' : '';
+    return `- ${s.title}${state} - ${when} - ${people} attendee(s) (id ${s.id})`;
+}
+// ---------------------------------------------------------------------------
+// orboto_list_ticket_schedules
+// ---------------------------------------------------------------------------
+export const listTicketSchedulesToolConfig = {
+    title: 'List a ticket\'s scheduled working sessions',
+    description: 'List the meeting / working sessions scheduled on a ticket (by key). Active sessions only by default; pass includeCancelled=true for history. Returns each session\'s id, title, window and attendee count - get the id here before cancelling one with orboto_cancel_ticket_session.',
+    inputSchema: z.object({
+        ticketKey: z.string().min(3),
+        includeCancelled: z.boolean().optional().describe('Include cancelled sessions (default: active only).'),
+    }).shape,
+    annotations: { readOnlyHint: true, idempotentHint: true },
+};
+export function makeListTicketSchedulesHandler(client) {
+    return async ({ ticketKey, includeCancelled }) => {
+        const ticket = await resolveTicketByKey(client, ticketKey);
+        const qs = includeCancelled ? '?includeCancelled=true' : '';
+        const rows = await client.get(`/tickets/${ticket.id}/schedules${qs}`);
+        return {
+            content: [{
+                    type: 'text',
+                    text: rows.length
+                        ? `Sessions on [${ticket.ticketKey}]:\n${rows.map(scheduleLine).join('\n')}`
+                        : `No scheduled sessions on [${ticket.ticketKey}].`,
+                }],
+            structuredContent: { ticketKey: ticket.ticketKey, schedules: rows },
+        };
+    };
+}
+// ---------------------------------------------------------------------------
+// orboto_schedule_ticket_session
+// ---------------------------------------------------------------------------
+export const scheduleTicketSessionToolConfig = {
+    title: 'Schedule a working session on a ticket',
+    description: 'Schedule a working session ("scope review", "design crit") on a ticket. Drops a plan-block on every orboto attendee and emails each attendee an iCal invite. startsAt/endsAt are ISO 8601 datetimes. attendeeUserIds are orboto user UUIDs (from orboto_list_users); externalEmails are non-orboto guests who get the invite but no plan-block. Title defaults to "Working session: <TICKET-KEY>".',
+    inputSchema: z.object({
+        ticketKey: z.string().min(3),
+        startsAt: z.string().datetime().describe('ISO 8601 start datetime.'),
+        endsAt: z.string().datetime().describe('ISO 8601 end datetime (must be after startsAt).'),
+        title: z.string().optional(),
+        location: z.string().optional().describe('Free text - Zoom URL, room name, "remote".'),
+        notes: z.string().optional(),
+        attendeeUserIds: z.array(z.string().uuid()).optional().describe('orboto attendee user UUIDs.'),
+        externalEmails: z.array(z.string().email()).optional().describe('External (non-orboto) guest emails.'),
+    }).shape,
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false },
+};
+export function makeScheduleTicketSessionHandler(client) {
+    return async (args) => {
+        const ticket = await resolveTicketByKey(client, args.ticketKey);
+        const body = {
+            startsAt: args.startsAt,
+            endsAt: args.endsAt,
+            attendeeUserIds: args.attendeeUserIds ?? [],
+            externalEmails: args.externalEmails ?? [],
+        };
+        if (args.title !== undefined)
+            body.title = args.title;
+        if (args.location !== undefined)
+            body.location = args.location;
+        if (args.notes !== undefined)
+            body.notes = args.notes;
+        const row = await client.post(`/tickets/${ticket.id}/schedules`, body);
+        const people = row.attendees.length + row.externalAttendees.length;
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Scheduled "${row.title}" on [${ticket.ticketKey}] (${row.startsAt} -> ${row.endsAt}) - ${people} attendee(s) invited. (id ${row.id})`,
+                }],
+            structuredContent: { ticketKey: ticket.ticketKey, scheduleId: row.id, schedule: row },
+        };
+    };
+}
+// ---------------------------------------------------------------------------
+// orboto_cancel_ticket_session
+// ---------------------------------------------------------------------------
+export const cancelTicketSessionToolConfig = {
+    title: 'Cancel a scheduled working session',
+    description: 'Cancel a working session on a ticket. Removes every attendee\'s plan-block and emails an iCal cancellation to all attendees. Get the scheduleId from orboto_list_ticket_schedules.',
+    inputSchema: z.object({
+        ticketKey: z.string().min(3),
+        scheduleId: z.string().uuid(),
+    }).shape,
+    annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true },
+};
+export function makeCancelTicketSessionHandler(client) {
+    return async ({ ticketKey, scheduleId }) => {
+        const ticket = await resolveTicketByKey(client, ticketKey);
+        const row = await client.delete(`/tickets/${ticket.id}/schedules/${scheduleId}`);
+        return {
+            content: [{ type: 'text', text: `Cancelled session "${row.title}" on [${ticket.ticketKey}]. Attendees notified.` }],
+            structuredContent: { ticketKey: ticket.ticketKey, scheduleId, cancelled: true },
+        };
+    };
+}

package/dist/tools/ticket-schedules.test.js

@@ -0,0 +1,102 @@
+/**
+ * ORB-626 - ticket meeting-schedule tool tests.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { OrbotoClient } from '../orboto-client.js';
+import { makeListTicketSchedulesHandler, makeScheduleTicketSessionHandler, makeCancelTicketSessionHandler, } from './ticket-schedules.js';
+beforeEach(() => { vi.restoreAllMocks(); });
+afterEach(() => { vi.restoreAllMocks(); });
+function stub(responses) {
+    const calls = [];
+    vi.spyOn(globalThis, 'fetch').mockImplementation(async (url, init) => {
+        const u = url.toString();
+        const m = init?.method ?? 'GET';
+        const b = init?.body ? JSON.parse(init.body) : undefined;
+        calls.push({ url: u, method: m, body: b });
+        const r = responses.shift();
+        if (!r)
+            throw new Error(`unexpected extra fetch ${m} ${u}`);
+        const payload = 'json' in r ? r.json : {};
+        return {
+            ok: r.ok ?? true,
+            status: r.status ?? 200,
+            statusText: 'OK',
+            json: async () => payload,
+            // delete<T> reads text() then JSON.parses it - serialise the payload.
+            text: async () => JSON.stringify(payload),
+        };
+    });
+    return calls;
+}
+const client = new OrbotoClient({ baseUrl: 'https://orboto.example.com', apiKey: 'orb_x' });
+const PROJ = { id: 'p1', key: 'ACME', name: 'Acme', description: null, status: 'active' };
+const TICKET = { id: 't1', projectId: 'p1', ticketKey: 'ACME-1', title: 'Bug' };
+function schedule(overrides = {}) {
+    return {
+        id: 's1', ticketId: 't1', createdBy: 'u1', title: 'Working session: ACME-1',
+        startsAt: '2026-07-20T10:00:00Z', endsAt: '2026-07-20T11:00:00Z',
+        location: null, notes: null, attendees: [{ userId: 'u2', email: 'a@x.io' }],
+        externalAttendees: [{ email: 'ext@client.com' }], sequence: 0,
+        cancelledAt: null, createdAt: 'now', updatedAt: 'now', ...overrides,
+    };
+}
+describe('orboto_list_ticket_schedules', () => {
+    it('lists active sessions by default', async () => {
+        const calls = stub([{ json: PROJ }, { json: TICKET }, { json: [schedule()] }]);
+        const res = await makeListTicketSchedulesHandler(client)({ ticketKey: 'ACME-1' });
+        expect(calls[2].method).toBe('GET');
+        expect(calls[2].url).toContain('/tickets/t1/schedules');
+        expect(calls[2].url).not.toContain('includeCancelled');
+        expect(res.structuredContent.schedules).toHaveLength(1);
+    });
+    it('passes includeCancelled=true when requested', async () => {
+        const calls = stub([{ json: PROJ }, { json: TICKET }, { json: [] }]);
+        await makeListTicketSchedulesHandler(client)({ ticketKey: 'ACME-1', includeCancelled: true });
+        expect(calls[2].url).toContain('includeCancelled=true');
+    });
+});
+describe('orboto_schedule_ticket_session', () => {
+    it('POSTs the session with attendees + external emails', async () => {
+        const calls = stub([{ json: PROJ }, { json: TICKET }, { json: schedule() }]);
+        const res = await makeScheduleTicketSessionHandler(client)({
+            ticketKey: 'ACME-1',
+            startsAt: '2026-07-20T10:00:00Z',
+            endsAt: '2026-07-20T11:00:00Z',
+            attendeeUserIds: ['u2'],
+            externalEmails: ['ext@client.com'],
+        });
+        expect(calls[2].method).toBe('POST');
+        expect(calls[2].url).toContain('/tickets/t1/schedules');
+        expect(calls[2].body).toEqual({
+            startsAt: '2026-07-20T10:00:00Z',
+            endsAt: '2026-07-20T11:00:00Z',
+            attendeeUserIds: ['u2'],
+            externalEmails: ['ext@client.com'],
+        });
+        expect(res.structuredContent.scheduleId).toBe('s1');
+    });
+    it('defaults attendee arrays to empty when omitted', async () => {
+        const calls = stub([{ json: PROJ }, { json: TICKET }, { json: schedule({ attendees: [], externalAttendees: [] }) }]);
+        await makeScheduleTicketSessionHandler(client)({
+            ticketKey: 'ACME-1',
+            startsAt: '2026-07-20T10:00:00Z',
+            endsAt: '2026-07-20T11:00:00Z',
+        });
+        expect(calls[2].body).toEqual({
+            startsAt: '2026-07-20T10:00:00Z',
+            endsAt: '2026-07-20T11:00:00Z',
+            attendeeUserIds: [],
+            externalEmails: [],
+        });
+    });
+});
+describe('orboto_cancel_ticket_session', () => {
+    it('DELETEs the session by id and reports the cancelled title', async () => {
+        const calls = stub([{ json: PROJ }, { json: TICKET }, { json: schedule({ cancelledAt: 'now' }) }]);
+        const res = await makeCancelTicketSessionHandler(client)({ ticketKey: 'ACME-1', scheduleId: 's1' });
+        expect(calls[2].method).toBe('DELETE');
+        expect(calls[2].url).toContain('/tickets/t1/schedules/s1');
+        expect(res.structuredContent.cancelled).toBe(true);
+        expect(res.content[0].text).toContain('Working session: ACME-1');
+    });
+});