@zeegme/cli 0.1.0

package/dist/commands/bookings.js

@@ -0,0 +1,144 @@
+import { unwrap } from '../api/client.js';
+import { UsageError } from '../errors.js';
+import { asJson, clockTime, collect, isoDate, localTimeZone, pageFooter, positiveInt } from './util.js';
+const inviteeNames = (row) => (row.invitees ?? []).map((invitee) => invitee.fullName ?? invitee.email);
+export function registerBookings(program, context) {
+    const bookings = program.command('bookings').description('Scheduled events (bookings)');
+    bookings
+        .command('list')
+        .description('List bookings you can see, soonest first')
+        .option('--status <status>', 'confirmed or cancelled')
+        .option('--from <datetime>', 'start at or after this ISO 8601 time')
+        .option('--to <datetime>', 'start at or before this ISO 8601 time')
+        .option('--invitee-email <email>', 'only bookings with this invitee')
+        .option('--host-email <email>', 'only bookings hosted by this user')
+        .option('--keyword <text>', 'search titles and invitees')
+        .option('--all', 'include your team’s bookings (admins)')
+        .option('--desc', 'latest first')
+        .option('--page <n>', 'page number', positiveInt('--page'))
+        .option('--count <n>', 'results per page (max 100)', positiveInt('--count'))
+        .action(async (options) => {
+        if (options.status !== undefined && options.status !== 'confirmed' && options.status !== 'cancelled') {
+            throw new UsageError('--status must be confirmed or cancelled.');
+        }
+        const ctx = context();
+        const data = asJson(await unwrap((await ctx.api()).GET('/scheduled-events', {
+            params: {
+                query: {
+                    status: options.status,
+                    minStartTime: options.from,
+                    maxStartTime: options.to,
+                    inviteeEmail: options.inviteeEmail,
+                    hostEmail: options.hostEmail,
+                    keyword: options.keyword,
+                    scope: options.all ? 'all' : undefined,
+                    sort: options.desc ? 'desc' : 'asc',
+                    page: options.page,
+                    count: options.count,
+                },
+            },
+        })));
+        ctx.print.list(data, (data.collection ?? []), [
+            { header: 'uuid', value: (row) => row.uuid },
+            { header: 'start', value: (row) => row.startTime },
+            { header: 'title', value: (row) => row.title },
+            { header: 'status', value: (row) => row.status },
+            { header: 'invitees', value: inviteeNames },
+        ], pageFooter(data.pagination));
+    });
+    bookings
+        .command('get <uuid>')
+        .description('Show one booking')
+        .action(async (uuid) => {
+        const ctx = context();
+        const data = asJson(await unwrap((await ctx.api()).GET('/scheduled-events/{uuid}', { params: { path: { uuid } } })));
+        ctx.print.record(data, asJson(data.resource));
+    });
+    bookings
+        .command('create <eventTypeUuid>')
+        .description('Book a meeting for an invitee (needs a paid plan; find a time with `zeeg availability` first)')
+        .requiredOption('--date <date>', 'day, YYYY-MM-DD', isoDate('--date'))
+        .requiredOption('--time <time>', 'start time, HH:mm in --tz', clockTime('--time'))
+        .requiredOption('--name <name>', 'invitee’s full name')
+        .requiredOption('--email <email>', 'invitee’s email; Zeeg sends the confirmation there')
+        .option('--tz <zone>', 'IANA time zone of --date and --time (default: this machine’s)')
+        .option('--duration <minutes>', 'meeting length (default: the event type’s)', positiveInt('--duration'))
+        .option('--phone <number>', 'invitee’s phone number, for phone-call locations')
+        .option('--guest <email>', 'add a guest, repeatable', collect)
+        .option('--location <type>', 'location type, when the event type offers several')
+        .option('--location-key <key>', 'exact location key from the event type')
+        .option('-y, --yes', 'book without asking')
+        .action(async (uuid, options) => {
+        const ctx = context();
+        const timeZone = options.tz ?? localTimeZone();
+        await ctx.confirm(`Book ${options.name} <${options.email}> on ${options.date} at ${options.time} (${timeZone})? Zeeg emails them a confirmation.`, options.yes);
+        const data = asJson(await unwrap((await ctx.api()).POST('/event', {
+            body: {
+                eventTypeId: uuid,
+                date: options.date,
+                start: options.time,
+                timeZone,
+                duration: options.duration,
+                name: options.name,
+                email: options.email,
+                phone: options.phone,
+                guests: options.guest,
+                location: options.location,
+                locationKey: options.locationKey,
+            },
+        })));
+        ctx.print.message(data, `Booked: ${data.title ?? 'meeting'} at ${data.startTime ?? `${options.date} ${options.time}`} (${data.uuid}).`);
+    });
+    bookings
+        .command('cancel <uuid>')
+        .description('Cancel a booking; Zeeg notifies the invitees')
+        .option('--reason <text>', 'shown to the invitees')
+        .option('-y, --yes', 'cancel without asking')
+        .action(async (uuid, options) => {
+        const ctx = context();
+        await ctx.confirm(`Cancel booking ${uuid}? The invitees are notified.`, options.yes);
+        const data = await unwrap((await ctx.api()).PUT('/scheduled-events/{uuid}/cancel', {
+            params: { path: { uuid } },
+            body: { cancellationReason: options.reason },
+        }));
+        ctx.print.message(data, `Cancelled ${uuid}.`);
+    });
+    bookings
+        .command('reschedule <uuid>')
+        .description('Move a booking to a new time; Zeeg notifies the invitees')
+        .requiredOption('--date <date>', 'new day, YYYY-MM-DD', isoDate('--date'))
+        .requiredOption('--time <time>', 'new start time, HH:mm', clockTime('--time'))
+        .option('--tz <zone>', 'IANA time zone of --date and --time (default: the invitee’s)')
+        .option('--duration <minutes>', 'new length', positiveInt('--duration'))
+        .option('--reason <text>', 'shown to the invitees')
+        .option('-y, --yes', 'reschedule without asking')
+        .action(async (uuid, options) => {
+        const ctx = context();
+        await ctx.confirm(`Move booking ${uuid} to ${options.date} ${options.time}? The invitees are notified.`, options.yes);
+        const data = asJson(await unwrap((await ctx.api()).PUT('/scheduled-events/{uuid}/reschedule', {
+            params: { path: { uuid } },
+            body: { date: options.date, start: options.time, timeZone: options.tz, duration: options.duration, reason: options.reason },
+        })));
+        ctx.print.message(data, `Rescheduled ${uuid} to ${options.date} ${options.time}.`);
+    });
+    bookings
+        .command('hand-over <uuid>')
+        .description('Hand a round-robin booking to another host')
+        .option('--to <email>', 'the new host (default: Zeeg picks the next available host)')
+        .option('--require-availability', 'only hand over to a host who is free then')
+        .option('--fallback-to-reschedule', 'offer the invitee a reschedule when nobody is free')
+        .option('-y, --yes', 'hand over without asking')
+        .action(async (uuid, options) => {
+        const ctx = context();
+        await ctx.confirm(`Hand booking ${uuid} over to ${options.to ?? 'another host'}?`, options.yes);
+        const data = await unwrap((await ctx.api()).PUT('/scheduled-events/{uuid}/handover', {
+            params: { path: { uuid } },
+            body: {
+                newHostEmail: options.to,
+                requireHostAvailability: options.requireAvailability,
+                fallbackToReschedule: options.fallbackToReschedule,
+            },
+        }));
+        ctx.print.message(data, `Handed over ${uuid}.`);
+    });
+}

package/dist/commands/calls.js

@@ -0,0 +1,41 @@
+import { readFile } from 'node:fs/promises';
+import { unwrap } from '../api/client.js';
+import { UsageError } from '../errors.js';
+import { asJson } from './util.js';
+export function registerCalls(program, context) {
+    const calls = program.command('calls').description('Calls with your AI phone agents');
+    calls
+        .command('start <agentUuid>')
+        .description('Have an AI phone agent call someone (uses AI minutes)')
+        .requiredOption('--phone <number>', 'number to call, in international format (+49…)')
+        .option('--email <email>', 'the person’s email')
+        .option('--name <name>', 'the person’s full name')
+        .option('--data <text>', 'what the agent should know during the call, as plain text or @file')
+        .option('--at <datetime>', 'call later, at this ISO 8601 time')
+        .option('-y, --yes', 'start the call without asking')
+        .action(async (agentUuid, options) => {
+        const additionalData = options.data !== undefined ? await textArgument(options.data) : undefined;
+        const ctx = context();
+        await ctx.confirm(`Have the agent call ${options.name ? `${options.name} at ` : ''}${options.phone}${options.at ? ` at ${options.at}` : ' now'}? This uses AI minutes.`, options.yes);
+        const data = asJson(await unwrap((await ctx.api()).POST('/agents/{agentUuid}/outbound-calls', {
+            params: { path: { agentUuid } },
+            body: {
+                phoneNumber: options.phone,
+                email: options.email,
+                fullName: options.name,
+                additionalData,
+                scheduledTime: options.at,
+            },
+        })));
+        ctx.print.message(data, `Call ${options.at ? 'scheduled' : 'started'} (${asJson(data.element).status ?? 'queued'}).`);
+    });
+}
+/** The API takes the agent's extra context as one string, so a file is sent as its text. */
+async function textArgument(raw) {
+    if (!raw.startsWith('@')) {
+        return raw;
+    }
+    return readFile(raw.slice(1), 'utf8').catch(() => {
+        throw new UsageError(`Could not read ${raw.slice(1)}.`);
+    });
+}

package/dist/commands/crm.js

@@ -0,0 +1,96 @@
+import { unwrap } from '../api/client.js';
+import { UsageError } from '../errors.js';
+import { asJson, jsonArgument, pageFooter, positiveInt } from './util.js';
+/** `people` and `companies` have their own endpoints; anything else is a custom object slug. */
+async function list(api, object, query) {
+    if (object === 'people') {
+        const data = asJson(await unwrap(api.GET('/crm/people', { params: { query } })));
+        return { data, rows: (data.data?.people ?? []) };
+    }
+    if (object === 'companies') {
+        const data = asJson(await unwrap(api.GET('/crm/companies', { params: { query } })));
+        return { data, rows: (data.data?.companies ?? []) };
+    }
+    const data = asJson(await unwrap(api.GET('/crm/{objectSlug}', { params: { path: { objectSlug: object }, query } })));
+    return { data, rows: (data.data?.records ?? []) };
+}
+async function get(api, object, id) {
+    if (object === 'people') {
+        return asJson(await unwrap(api.GET('/crm/people/{id}', { params: { path: { id } } })));
+    }
+    if (object === 'companies') {
+        return asJson(await unwrap(api.GET('/crm/companies/{id}', { params: { path: { id } } })));
+    }
+    return asJson(await unwrap(api.GET('/crm/{objectSlug}/{recordId}', { params: { path: { objectSlug: object, recordId: id } } })));
+}
+async function upsert(api, object, matchingAttribute, body) {
+    if (object === 'people') {
+        return asJson(await unwrap(api.PUT('/crm/people', { params: { query: { matchingAttribute } }, body: body })));
+    }
+    if (object === 'companies') {
+        if (matchingAttribute !== 'domain') {
+            throw new UsageError('Companies are matched on their domain: pass --match domain.');
+        }
+        return asJson(await unwrap(api.PUT('/crm/companies', { params: { query: { matchingAttribute } }, body: body })));
+    }
+    return asJson(await unwrap(api.PUT('/crm/{objectSlug}', {
+        params: { path: { objectSlug: object }, query: { matchingAttribute } },
+        body: body,
+    })));
+}
+/** The record inside a get/upsert answer, whatever key the endpoint wraps it in. */
+function recordOf(data) {
+    const inner = asJson(data.data ?? data);
+    return asJson(inner.person ?? inner.company ?? inner.record ?? inner);
+}
+function displayName(row) {
+    if (row.firstName !== undefined || row.lastName !== undefined) {
+        return [row.firstName, row.lastName].filter(Boolean).join(' ');
+    }
+    return row.name ?? row.title ?? row.displayName;
+}
+export function registerCrm(program, context) {
+    const crm = program.command('crm').description('CRM people, companies and custom object records');
+    const objectHelp = 'people, companies, or a custom object slug';
+    crm
+        .command('list <object>')
+        .description(`List CRM records (${objectHelp})`)
+        .option('--page <n>', 'page number', positiveInt('--page'))
+        .option('--per-page <n>', 'results per page (max 100)', positiveInt('--per-page'))
+        .option('--sort-by <attribute>', 'attribute to sort on')
+        .option('--sort-order <order>', 'asc or desc')
+        .option('--search <text>', 'only records matching this text')
+        .action(async (object, options) => {
+        if (options.sortOrder !== undefined && !['asc', 'desc'].includes(options.sortOrder)) {
+            throw new UsageError('--sort-order must be asc or desc.');
+        }
+        const ctx = context();
+        const { data, rows } = await list(await ctx.api(), object, options);
+        ctx.print.list(data, rows, [
+            { header: 'id', value: (row) => row.id },
+            { header: 'name', value: displayName },
+            { header: 'email', value: (row) => row.emails ?? row.domain },
+            { header: 'updated', value: (row) => row.updatedAt },
+        ], pageFooter(data.data?.pagination));
+    });
+    crm
+        .command('get <object> <id>')
+        .description(`Show one CRM record (${objectHelp})`)
+        .action(async (object, id) => {
+        const ctx = context();
+        const data = await get(await ctx.api(), object, id);
+        ctx.print.record(data, recordOf(data));
+    });
+    crm
+        .command('upsert <object>')
+        .description(`Create a CRM record, or update the one that matches (${objectHelp})`)
+        .requiredOption('--match <attribute>', 'attribute that identifies an existing record, e.g. emails or domain')
+        .requiredOption('--data <json>', 'the record as a JSON object, inline or as @file.json')
+        .action(async (object, options) => {
+        const body = await jsonArgument(options.data);
+        const ctx = context();
+        const data = await upsert(await ctx.api(), object, options.match, body);
+        const record = recordOf(data);
+        ctx.print.message(data, `Saved ${object} record ${record.id ?? ''}.`.replace(' .', '.'));
+    });
+}

package/dist/commands/eventTypes.js

@@ -0,0 +1,56 @@
+import { unwrap } from '../api/client.js';
+import { addDays, asJson, isoDate, localTimeZone, pageFooter, positiveInt } from './util.js';
+export function registerEventTypes(program, context) {
+    const eventTypes = program.command('event-types').description('Scheduling pages (event types)');
+    eventTypes
+        .command('list')
+        .description('List event types you can see')
+        .option('--user-slug <slug>', 'only this host’s event types')
+        .option('--email <email>', 'only the event types of the host with this email')
+        .option('--page <n>', 'page number', positiveInt('--page'))
+        .option('--count <n>', 'results per page', positiveInt('--count'))
+        .action(async (options) => {
+        const ctx = context();
+        const data = asJson(await unwrap((await ctx.api()).GET('/event-types', {
+            params: { query: { userSlug: options.userSlug, email: options.email, page: options.page, count: options.count } },
+        })));
+        ctx.print.list(data, (data.collection ?? []), [
+            { header: 'uuid', value: (row) => row.uuid },
+            { header: 'title', value: (row) => row.title },
+            { header: 'minutes', value: (row) => row.duration },
+            { header: 'active', value: (row) => (row.isActive ? 'yes' : 'no') },
+            { header: 'url', value: (row) => row.schedulingUrl },
+        ], pageFooter(data.pagination));
+    });
+    eventTypes
+        .command('get <uuid>')
+        .description('Show one event type')
+        .action(async (uuid) => {
+        const ctx = context();
+        const data = asJson(await unwrap((await ctx.api()).GET('/event-types/{uuid}', { params: { path: { uuid } } })));
+        ctx.print.record(data, asJson(data.resource));
+    });
+    program
+        .command('availability <eventTypeUuid>')
+        .description('Available start times for an event type (needs a paid plan)')
+        .option('--from <date>', 'first day, YYYY-MM-DD (default: today)', isoDate('--from'))
+        .option('--to <date>', 'last day, YYYY-MM-DD (default: six days after --from)', isoDate('--to'))
+        .option('--tz <zone>', 'IANA time zone for the times (default: this machine’s)')
+        .option('--duration <minutes>', 'meeting length, when the event type offers several', positiveInt('--duration'))
+        .action(async (uuid, options) => {
+        const ctx = context();
+        const from = options.from ?? new Date().toISOString().slice(0, 10);
+        const to = options.to ?? addDays(new Date(`${from}T00:00:00Z`), 6);
+        const data = asJson(await unwrap((await ctx.api()).GET('/event-types/{uuid}/availability', {
+            params: {
+                path: { uuid },
+                query: { startDate: from, endDate: to, timeZone: options.tz ?? localTimeZone(), duration: options.duration },
+            },
+        })));
+        const days = (data.availability ?? []).filter((day) => Array.isArray(day.slots) && day.slots.length > 0);
+        ctx.print.list(data, days, [
+            { header: 'date', value: (day) => day.date },
+            { header: `times (${data.timeZone ?? options.tz ?? localTimeZone()})`, full: true, value: (day) => day.slots.map((slot) => (typeof slot === 'string' ? slot : asJson(slot).time)).join(' ') },
+        ]);
+    });
+}

package/dist/commands/forms.js

@@ -0,0 +1,49 @@
+import { unwrap } from '../api/client.js';
+import { asJson, pageFooter, positiveInt } from './util.js';
+export function registerForms(program, context) {
+    const forms = program.command('forms').description('Routing forms');
+    forms
+        .command('list')
+        .description('List routing forms')
+        .option('--page <n>', 'page number', positiveInt('--page'))
+        .option('--count <n>', 'results per page', positiveInt('--count'))
+        .action(async (options) => {
+        const ctx = context();
+        const data = asJson(await unwrap((await ctx.api()).GET('/routing-forms', { params: { query: options } })));
+        ctx.print.list(data, (data.data?.routingForms ?? []), [
+            { header: 'id', value: (row) => row.id },
+            { header: 'name', value: (row) => row.name },
+            { header: 'active', value: (row) => (row.isActive ? 'yes' : 'no') },
+            { header: 'updated', value: (row) => row.updatedAt },
+        ], pageFooter(data.data?.pagination));
+    });
+    forms
+        .command('submissions')
+        .description('List routing form submissions, newest first')
+        .option('--form <id>', 'only this routing form’s submissions')
+        .option('--from <datetime>', 'created at or after this ISO 8601 time')
+        .option('--to <datetime>', 'created at or before this ISO 8601 time')
+        .option('--page <n>', 'page number', positiveInt('--page'))
+        .option('--count <n>', 'results per page', positiveInt('--count'))
+        .action(async (options) => {
+        const ctx = context();
+        const data = asJson(await unwrap((await ctx.api()).GET('/routing-form-submissions', {
+            params: {
+                query: {
+                    routingFormId: options.form,
+                    minCreatedAt: options.from,
+                    maxCreatedAt: options.to,
+                    sort: 'desc',
+                    page: options.page,
+                    count: options.count,
+                },
+            },
+        })));
+        ctx.print.list(data, (data.data?.submissions ?? []), [
+            { header: 'id', value: (row) => row.id },
+            { header: 'created', value: (row) => row.createdAt },
+            { header: 'form', value: (row) => row.routingForm?.name ?? row.routingFormId },
+            { header: 'route', value: (row) => row.routeType ?? row.route?.type },
+        ], pageFooter(data.data?.pagination));
+    });
+}

package/dist/commands/notes.js

@@ -0,0 +1,28 @@
+import { unwrap } from '../api/client.js';
+import { asJson } from './util.js';
+export function registerNotes(program, context) {
+    const notes = program.command('notes').description('Notes on bookings');
+    notes
+        .command('list <bookingUuid>')
+        .description('List the notes on a booking')
+        .action(async (uuid) => {
+        const ctx = context();
+        const data = asJson(await unwrap((await ctx.api()).GET('/notes/event/{uuid}', { params: { path: { uuid } } })));
+        ctx.print.list(data, (data.list ?? []), [
+            { header: 'id', value: (row) => row.id },
+            { header: 'created', value: (row) => row.createdAt },
+            { header: 'by', value: (row) => row.creator?.fullName ?? row.creator?.email },
+            { header: 'note', value: (row) => row.note },
+        ]);
+    });
+    notes
+        .command('add <bookingUuid> <text...>')
+        .description('Add a note to a booking (basic HTML such as <b> is kept)')
+        .action(async (uuid, text) => {
+        const ctx = context();
+        const data = await unwrap((await ctx.api()).POST('/notes', {
+            body: { relation: 'event', uuid, note: text.join(' ') },
+        }));
+        ctx.print.message(data, `Note added to ${uuid}.`);
+    });
+}

package/dist/commands/schedules.js

@@ -0,0 +1,56 @@
+import { unwrap } from '../api/client.js';
+import { UsageError } from '../errors.js';
+import { asJson, collect, isoDate, pageFooter, positiveInt } from './util.js';
+async function ownEmail(api) {
+    return (await unwrap(api.GET('/whoami'))).email;
+}
+export function registerSchedules(program, context) {
+    const schedules = program.command('schedules').description('Availability schedules');
+    schedules
+        .command('list')
+        .description('List a user’s availability schedules')
+        .option('--email <email>', 'whose schedules (default: yours)')
+        .option('--page <n>', 'page number', positiveInt('--page'))
+        .option('--count <n>', 'results per page', positiveInt('--count'))
+        .action(async (options) => {
+        const ctx = context();
+        const api = await ctx.api();
+        const data = asJson(await unwrap(api.GET('/schedules', {
+            params: { query: { email: options.email ?? await ownEmail(api), page: options.page, count: options.count } },
+        })));
+        ctx.print.list(data, (data.collection ?? []), [
+            { header: 'uuid', value: (row) => row.uuid },
+            { header: 'title', value: (row) => row.title },
+            { header: 'time zone', value: (row) => row.timezone },
+            { header: 'default', value: (row) => (row.isDefault ? 'yes' : 'no') },
+        ], pageFooter(data.pagination));
+    });
+    const timeOff = program.command('time-off').description('Time off (vacation, out of office)');
+    timeOff
+        .command('add')
+        .description('Block days as time off')
+        .requiredOption('--start <date>', 'first day off, YYYY-MM-DD', isoDate('--start'))
+        .requiredOption('--end <date>', 'last day off, YYYY-MM-DD', isoDate('--end'))
+        .requiredOption('--title <title>', 'shown on the calendar, e.g. "Summer holiday"')
+        .option('--type <type>', 'vacation or out_of_office', 'vacation')
+        .option('--note <text>', 'a note for your team')
+        .option('--email <email>', 'whose time off, repeatable (default: yours)', collect)
+        .action(async (options) => {
+        if (options.type !== 'vacation' && options.type !== 'out_of_office') {
+            throw new UsageError('--type must be vacation or out_of_office.');
+        }
+        const ctx = context();
+        const api = await ctx.api();
+        const data = await unwrap(api.POST('/time-off', {
+            body: {
+                users: { emails: options.email ?? [await ownEmail(api)] },
+                type: options.type,
+                title: options.title,
+                startDate: options.start,
+                endDate: options.end,
+                note: options.note,
+            },
+        }));
+        ctx.print.message(data, `Time off added from ${options.start} to ${options.end}.`);
+    });
+}

package/dist/commands/util.js

@@ -0,0 +1,68 @@
+import { readFile } from 'node:fs/promises';
+import { UsageError } from '../errors.js';
+export function asJson(value) {
+    return value !== null && typeof value === 'object' ? value : {};
+}
+export function positiveInt(name) {
+    return (raw) => {
+        const value = Number(raw);
+        if (!Number.isInteger(value) || value < 1) {
+            throw new UsageError(`${name} must be a whole number of 1 or more, not "${raw}".`);
+        }
+        return value;
+    };
+}
+export function isoDate(name) {
+    return (raw) => {
+        if (!/^\d{4}-\d{2}-\d{2}$/.test(raw) || Number.isNaN(Date.parse(raw))) {
+            throw new UsageError(`${name} must be a date as YYYY-MM-DD, not "${raw}".`);
+        }
+        return raw;
+    };
+}
+export function clockTime(name) {
+    return (raw) => {
+        if (!/^([01]\d|2[0-3]):[0-5]\d$/.test(raw)) {
+            throw new UsageError(`${name} must be a 24-hour time as HH:mm, not "${raw}".`);
+        }
+        return raw;
+    };
+}
+export function collect(value, previous = []) {
+    return [...previous, value];
+}
+/** `--data '{"a":1}'` or `--data @record.json`. */
+export async function jsonArgument(raw) {
+    const text = raw.startsWith('@') ? await readFile(raw.slice(1), 'utf8').catch(() => {
+        throw new UsageError(`Could not read ${raw.slice(1)}.`);
+    }) : raw;
+    try {
+        const value = JSON.parse(text);
+        if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+            throw new Error('not an object');
+        }
+        return value;
+    }
+    catch {
+        throw new UsageError('--data must be a JSON object, inline or as @file.json.');
+    }
+}
+export function localTimeZone() {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
+}
+export function addDays(date, days) {
+    const copy = new Date(date);
+    copy.setUTCDate(copy.getUTCDate() + days);
+    return copy.toISOString().slice(0, 10);
+}
+/** "Page 2 of 5 (93 in total)" from either pagination shape the v2 API uses. */
+export function pageFooter(pagination) {
+    const p = asJson(pagination);
+    const current = p.currentPage;
+    const last = p.totalPages ?? p.lastPage;
+    const total = p.total ?? p.totalItems;
+    if (current === undefined || last === undefined) {
+        return undefined;
+    }
+    return `Page ${current} of ${last}${total !== undefined ? ` (${total} in total)` : ''}. Use --page to see more.`;
+}

package/dist/config.js

@@ -0,0 +1,41 @@
+import { UsageError } from './errors.js';
+export const DEFAULT_BASE_URL = 'https://api.zeeg.me';
+/**
+ * The CLI's OAuth client. The backend inserts it with this id in every environment
+ * (config('mcp.cli.client_id')), so one build reaches local, staging and production.
+ */
+export const DEFAULT_CLIENT_ID = '1000001';
+/** The v2 scopes the commands need. The server narrows them to what the plan allows. */
+export const SCOPES = [
+    'event_types:read',
+    'timetable',
+    'schedules:read',
+    'schedules:write',
+    'events:read',
+    'events:write',
+    'booking',
+    'notes:read',
+    'notes:write',
+    'crm:read',
+    'crm:write',
+    'routing_forms:read',
+    'outbound-calls:write',
+    'agents:read',
+];
+export function resolveBaseUrl(flag, env = process.env) {
+    const raw = flag ?? env.ZEEG_API_URL ?? DEFAULT_BASE_URL;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new UsageError(`"${raw}" is not a URL. Pass the API origin, e.g. --base-url https://api.zeeg.me`);
+    }
+    if (url.protocol !== 'https:' && !['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)) {
+        throw new UsageError('The API URL must use https (plain http is accepted for localhost only).');
+    }
+    return url.origin + url.pathname.replace(/\/+$/, '');
+}
+export function clientId(env = process.env) {
+    return env.ZEEG_CLIENT_ID ?? DEFAULT_CLIENT_ID;
+}

package/dist/context.js

@@ -0,0 +1,66 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { createApi } from './api/client.js';
+import { HttpOAuthClient } from './auth/oauth.js';
+import { Session } from './auth/session.js';
+import { openTokenStore } from './auth/tokenStore.js';
+import { clientId, resolveBaseUrl } from './config.js';
+import { UsageError } from './errors.js';
+import { createPrinter, selectOutputMode } from './output.js';
+import { VERSION } from './version.js';
+const USER_AGENT = `zeeg-cli/${VERSION} (node ${process.versions.node}; ${process.platform})`;
+export function createContext(options) {
+    const baseUrl = resolveBaseUrl(options.baseUrl);
+    const oauth = new HttpOAuthClient(baseUrl, clientId(), USER_AGENT);
+    let store;
+    let session;
+    const context = {
+        baseUrl,
+        print: createPrinter(selectOutputMode({ json: options.json, isTTY: process.stdout.isTTY })),
+        oauth,
+        store: () => (store ??= openTokenStore(baseUrl)),
+        session: () => (session ??= context.store().then((tokens) => new Session(tokens, oauth))),
+        api: async () => createApi(baseUrl, await context.session(), USER_AGENT),
+        say: (message) => process.stderr.write(`${message}\n`),
+        confirm: async (question, yes) => {
+            if (yes === true) {
+                return;
+            }
+            if (!process.stdin.isTTY || !process.stderr.isTTY) {
+                throw new UsageError(`${question} Pass --yes to confirm when there is no terminal to ask in.`);
+            }
+            const prompt = createInterface({ input: process.stdin, output: process.stderr });
+            const answer = await prompt.question(`${question} [y/N] `);
+            prompt.close();
+            if (!/^y(es)?$/i.test(answer.trim())) {
+                throw new UsageError('Nothing was changed.');
+            }
+        },
+        openBrowser,
+    };
+    return context;
+}
+function openBrowser(url) {
+    const [command, args] = process.platform === 'darwin'
+        ? ['open', [url]]
+        : process.platform === 'win32'
+            ? ['cmd', ['/c', 'start', '""', url.replace(/&/g, '^&')]]
+            : ['xdg-open', [url]];
+    // A Linux host without a display (SSH, a server) has nothing to open the page in.
+    if (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+        return Promise.resolve(false);
+    }
+    return new Promise((resolve) => {
+        try {
+            const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+            child.once('error', () => resolve(false));
+            child.once('spawn', () => {
+                child.unref();
+                resolve(true);
+            });
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}