@circleback/cli 0.1.0

package/dist/auth/oauth.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forceRefreshToken = exports.getValidAccessToken = exports.login = exports.refreshAccessToken = void 0;
+const node_child_process_1 = require("node:child_process");
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const server_1 = require("./server");
+const tokenStorage_1 = require("./tokenStorage");
+const generatePkce = () => {
+    const verifier = node_crypto_1.default.randomBytes(32).toString('base64url');
+    const challenge = node_crypto_1.default
+        .createHash('sha256')
+        .update(verifier)
+        .digest('base64url');
+    return { verifier, challenge };
+};
+const generateState = () => node_crypto_1.default.randomBytes(16).toString('base64url');
+const registerClient = async (redirectUri) => {
+    const response = await fetch(`${constants_1.BASE_URL}/api/oauth/register`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            client_name: constants_1.CLIENT_NAME,
+            client_type: 'CLI',
+            redirect_uris: [redirectUri],
+            token_endpoint_auth_method: 'none',
+            grant_types: ['authorization_code', 'refresh_token'],
+            response_types: ['code'],
+        }),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Client registration failed: ${body}.`);
+    }
+    const data = await response.json();
+    if (typeof data !== 'object' ||
+        data === null ||
+        !('client_id' in data) ||
+        typeof data.client_id !== 'string') {
+        throw new Error('Invalid client registration response.');
+    }
+    return data.client_id;
+};
+const exchangeCode = async (params) => {
+    const body = new URLSearchParams({
+        grant_type: 'authorization_code',
+        code: params.code,
+        redirect_uri: params.redirectUri,
+        client_id: params.clientId,
+        code_verifier: params.codeVerifier,
+    });
+    const response = await fetch(`${constants_1.BASE_URL}/api/oauth/access-token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: body.toString(),
+    });
+    if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`Token exchange failed: ${errorBody}.`);
+    }
+    const tokenData = await response.json();
+    if (!(0, types_1.isOAuthTokenResponse)(tokenData)) {
+        throw new Error('Invalid token exchange response.');
+    }
+    return tokenData;
+};
+const refreshAccessToken = async (refreshToken, clientId) => {
+    const body = new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: refreshToken,
+        client_id: clientId,
+    });
+    const response = await fetch(`${constants_1.BASE_URL}/api/oauth/access-token`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: body.toString(),
+    });
+    if (!response.ok) {
+        const errorBody = await response.text();
+        throw new Error(`Token refresh failed: ${errorBody}.`);
+    }
+    const tokenData = await response.json();
+    if (!(0, types_1.isOAuthTokenResponse)(tokenData)) {
+        throw new Error('Invalid token refresh response.');
+    }
+    return tokenData;
+};
+exports.refreshAccessToken = refreshAccessToken;
+const login = async () => {
+    const { port, waitForCallback, shutdown } = await (0, server_1.startCallbackServer)();
+    const redirectUri = `http://127.0.0.1:${port}`;
+    try {
+        const clientId = await registerClient(redirectUri);
+        const { verifier, challenge } = generatePkce();
+        const state = generateState();
+        const authorizeUrl = new URL(`${constants_1.BASE_URL}/api/oauth/authorize`);
+        authorizeUrl.searchParams.set('client_id', clientId);
+        authorizeUrl.searchParams.set('redirect_uri', redirectUri);
+        authorizeUrl.searchParams.set('response_type', 'code');
+        authorizeUrl.searchParams.set('scope', constants_1.OAUTH_SCOPE);
+        authorizeUrl.searchParams.set('state', state);
+        authorizeUrl.searchParams.set('code_challenge', challenge);
+        authorizeUrl.searchParams.set('code_challenge_method', 'S256');
+        const url = authorizeUrl.toString();
+        const isWindows = process.platform === 'win32';
+        const [command, ...arguments_] = isWindows
+            ? ['start', '', url]
+            : process.platform === 'darwin'
+                ? ['open', url]
+                : ['xdg-open', url];
+        (0, node_child_process_1.spawn)(command, arguments_, { stdio: 'ignore', shell: isWindows });
+        const callback = await waitForCallback();
+        if (callback.state !== state) {
+            throw new Error('State mismatch. Possible CSRF attack.');
+        }
+        const tokenResponse = await exchangeCode({
+            code: callback.code,
+            redirectUri,
+            clientId,
+            codeVerifier: verifier,
+        });
+        const tokens = (0, tokenStorage_1.buildStoredTokens)(tokenResponse, clientId);
+        (0, tokenStorage_1.saveTokens)(tokens);
+        return tokens;
+    }
+    catch (error) {
+        shutdown();
+        throw error;
+    }
+};
+exports.login = login;
+const requireTokens = () => {
+    const tokens = (0, tokenStorage_1.loadTokens)();
+    if (!tokens) {
+        throw new Error('Not authenticated. Run `circleback login` to authenticate.');
+    }
+    return tokens;
+};
+const refreshAndSave = async (tokens) => {
+    const refreshed = await (0, exports.refreshAccessToken)(tokens.refreshToken, tokens.clientId);
+    const updatedTokens = (0, tokenStorage_1.buildStoredTokens)(refreshed, tokens.clientId);
+    (0, tokenStorage_1.saveTokens)(updatedTokens);
+    return updatedTokens.accessToken;
+};
+const getValidAccessToken = async () => {
+    const tokens = requireTokens();
+    const bufferSeconds = 60;
+    const isExpired = Math.floor(Date.now() / 1000) >= tokens.expiresAt - bufferSeconds;
+    if (!isExpired)
+        return tokens.accessToken;
+    return refreshAndSave(tokens);
+};
+exports.getValidAccessToken = getValidAccessToken;
+const forceRefreshToken = async () => {
+    const tokens = requireTokens();
+    return refreshAndSave(tokens);
+};
+exports.forceRefreshToken = forceRefreshToken;

package/dist/auth/server.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCallbackServer = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const node_url_1 = require("node:url");
+const constants_1 = require("../constants");
+const SUCCESS_HTML = `
+<!DOCTYPE html>
+<html>
+  <head><title>Circleback CLI</title></head>
+  <body style="font-family: system-ui, sans-serif; display: flex; justify-content: center; align-items: center; height: 100vh; margin: 0;">
+    <div style="text-align: center;">
+      <h1>Authentication successful</h1>
+      <p>You can close this tab and return to the terminal.</p>
+    </div>
+  </body>
+</html>
+`;
+const startCallbackServer = () => new Promise((resolve, reject) => {
+    let callbackResolve;
+    let callbackReject;
+    const callbackPromise = new Promise((resolveCallback, rejectCallback) => {
+        callbackResolve = resolveCallback;
+        callbackReject = rejectCallback;
+    });
+    const server = node_http_1.default.createServer((request, response) => {
+        if (!request.url) {
+            response.writeHead(400);
+            response.end('Bad request.');
+            return;
+        }
+        const url = new node_url_1.URL(request.url, `http://127.0.0.1`);
+        const code = url.searchParams.get('code');
+        const state = url.searchParams.get('state');
+        const error = url.searchParams.get('error');
+        if (error) {
+            response.writeHead(400, { 'Content-Type': 'text/html' });
+            const escapedError = error
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;')
+                .replace(/'/g, '&#039;');
+            response.end(`<h1>Authentication failed: ${escapedError}</h1>`);
+            callbackReject(new Error(`OAuth error: ${error}.`));
+            return;
+        }
+        if (!code || !state) {
+            response.writeHead(400, { 'Content-Type': 'text/html' });
+            response.end('<h1>Missing authorization code.</h1>');
+            return;
+        }
+        response.writeHead(200, { 'Content-Type': 'text/html' });
+        response.end(SUCCESS_HTML);
+        callbackResolve({ code, state });
+    });
+    const timeout = setTimeout(() => {
+        shutdown();
+        callbackReject(new Error('Authentication timed out. Please try again.'));
+    }, constants_1.CALLBACK_TIMEOUT_MILLISECONDS);
+    let isShutdown = false;
+    const shutdown = () => {
+        if (isShutdown)
+            return;
+        isShutdown = true;
+        clearTimeout(timeout);
+        server.close();
+    };
+    server.listen(0, '127.0.0.1', () => {
+        const address = server.address();
+        if (!address || typeof address === 'string') {
+            reject(new Error('Failed to start callback server.'));
+            return;
+        }
+        resolve({
+            port: address.port,
+            waitForCallback: async () => {
+                const result = await callbackPromise;
+                shutdown();
+                return result;
+            },
+            shutdown,
+        });
+    });
+});
+exports.startCallbackServer = startCallbackServer;

package/dist/auth/tokenStorage.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearTokens = exports.saveTokens = exports.loadTokens = exports.buildStoredTokens = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const DIRECTORY_PERMISSIONS_MODE = 0o700;
+const FILE_PERMISSIONS_MODE = 0o600;
+const buildStoredTokens = (response, clientId) => ({
+    accessToken: response.access_token,
+    refreshToken: response.refresh_token,
+    expiresAt: Math.floor(Date.now() / 1000) + response.expires_in,
+    clientId,
+    scope: response.scope,
+});
+exports.buildStoredTokens = buildStoredTokens;
+const loadTokens = () => {
+    try {
+        const content = node_fs_1.default.readFileSync(constants_1.TOKENS_FILE, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (!(0, types_1.isStoredTokens)(parsed))
+            return;
+        return parsed;
+    }
+    catch {
+        return;
+    }
+};
+exports.loadTokens = loadTokens;
+const saveTokens = (tokens) => {
+    node_fs_1.default.mkdirSync(constants_1.CONFIG_DIRECTORY, {
+        recursive: true,
+        mode: DIRECTORY_PERMISSIONS_MODE,
+    });
+    node_fs_1.default.writeFileSync(constants_1.TOKENS_FILE, JSON.stringify(tokens, null, 2), {
+        mode: FILE_PERMISSIONS_MODE,
+    });
+};
+exports.saveTokens = saveTokens;
+const clearTokens = () => {
+    try {
+        node_fs_1.default.unlinkSync(constants_1.TOKENS_FILE);
+    }
+    catch {
+        // File may not exist.
+    }
+};
+exports.clearTokens = clearTokens;

package/dist/client/jsonRpc.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callTool = void 0;
+const constants_1 = require("../constants");
+const types_1 = require("../types");
+const oauth_1 = require("../auth/oauth");
+const TOOLS_CALL_METHOD = 'tools/call';
+let requestId = 0;
+const nextId = () => ++requestId;
+const extractErrorMessage = async (response) => {
+    const text = await response.text();
+    try {
+        const body = JSON.parse(text);
+        if (typeof body !== 'object' || body === null)
+            return text;
+        const error = 'error' in body && typeof body.error === 'string' ? body.error : undefined;
+        const message = 'message' in body && typeof body.message === 'string'
+            ? body.message
+            : undefined;
+        return error ?? message ?? text;
+    }
+    catch {
+        return text;
+    }
+};
+const HTTP_ERROR_MESSAGES = {
+    401: 'Authentication expired. Run `circleback login` to re-authenticate.',
+    403: 'Permission denied.',
+    404: 'Resource not found.',
+    429: 'Rate limit exceeded. Please try again later.',
+};
+const sendRequest = async (method, params, accessToken) => fetch(`${constants_1.BASE_URL}/api/mcp`, {
+    method: 'POST',
+    headers: {
+        'Content-Type': 'application/json',
+        Accept: 'application/json, text/event-stream',
+        Authorization: `Bearer ${accessToken}`,
+    },
+    body: JSON.stringify({
+        jsonrpc: '2.0',
+        id: nextId(),
+        method,
+        params,
+    }),
+});
+const parseResponse = async (response) => {
+    const contentType = response.headers.get('content-type') ?? '';
+    if (contentType.includes('text/event-stream')) {
+        return parseSSEResponse(response);
+    }
+    const body = await response.json();
+    if (!(0, types_1.isJsonRpcResponse)(body)) {
+        throw new Error('Invalid JSON-RPC response.');
+    }
+    if (body.error) {
+        throw new Error(body.error.message);
+    }
+    const textContent = body.result?.content?.find((item) => item.type === 'text');
+    if (!textContent) {
+        throw new Error('No text content in response.');
+    }
+    return textContent.text;
+};
+const parseSSEResponse = async (response) => {
+    const text = await response.text();
+    const results = text
+        .split('\n')
+        .filter((line) => line.startsWith('data: '))
+        .flatMap((line) => {
+        const data = line.slice(6);
+        try {
+            const parsed = JSON.parse(data);
+            if (!(0, types_1.isJsonRpcResponse)(parsed))
+                return [];
+            if (parsed.error) {
+                throw new Error(parsed.error.message);
+            }
+            const textContent = parsed.result?.content?.find((item) => item.type === 'text');
+            return textContent ? [textContent.text] : [];
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                return [];
+            throw error;
+        }
+    });
+    if (results.length === 0) {
+        throw new Error('No text content in SSE response.');
+    }
+    return results.join('');
+};
+const sendRequestWithNetworkError = async (method, params, accessToken) => {
+    try {
+        return await sendRequest(method, params, accessToken);
+    }
+    catch (error) {
+        if (error instanceof TypeError && error.message.includes('fetch failed')) {
+            throw new Error('Network error. Check your internet connection and try again.');
+        }
+        throw error;
+    }
+};
+const retryWithRefresh = async (method, params) => {
+    const accessToken = await (0, oauth_1.forceRefreshToken)();
+    const response = await sendRequestWithNetworkError(method, params, accessToken);
+    if (!response.ok) {
+        const message = await extractErrorMessage(response);
+        throw new Error(message);
+    }
+    return parseResponse(response);
+};
+const callTool = async (toolName, toolArguments) => {
+    const accessToken = await (0, oauth_1.getValidAccessToken)();
+    const params = { name: toolName, arguments: toolArguments };
+    const response = await sendRequestWithNetworkError(TOOLS_CALL_METHOD, params, accessToken);
+    if (response.status === 401) {
+        return retryWithRefresh(TOOLS_CALL_METHOD, params);
+    }
+    if (!response.ok) {
+        const fallback = HTTP_ERROR_MESSAGES[response.status];
+        const serverMessage = await extractErrorMessage(response);
+        throw new Error(serverMessage ||
+            fallback ||
+            `Request failed with status ${response.status}.`);
+    }
+    return parseResponse(response);
+};
+exports.callTool = callTool;

package/dist/commands/auth.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logoutCommand = exports.loginCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const oauth_1 = require("../auth/oauth");
+const tokenStorage_1 = require("../auth/tokenStorage");
+exports.loginCommand = new commander_1.Command('login')
+    .description('Authenticate with Circleback via browser.')
+    .action(async () => {
+    try {
+        const existing = (0, tokenStorage_1.loadTokens)();
+        if (existing) {
+            console.log(chalk_1.default.yellow('Already authenticated. Run `circleback logout` first to re-authenticate.'));
+            return;
+        }
+        console.log('Opening browser for authentication…');
+        await (0, oauth_1.login)();
+        console.log(chalk_1.default.green('Authentication successful.'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Authentication failed.';
+        console.error(chalk_1.default.red(message));
+        process.exit(1);
+    }
+});
+exports.logoutCommand = new commander_1.Command('logout')
+    .description('Clear stored authentication tokens.')
+    .action(() => {
+    const existing = (0, tokenStorage_1.loadTokens)();
+    if (!existing) {
+        console.log(chalk_1.default.yellow('Not currently authenticated.'));
+        return;
+    }
+    (0, tokenStorage_1.clearTokens)();
+    console.log(chalk_1.default.green('Logged out successfully.'));
+});

package/dist/commands/calendar.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchCalendarCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const jsonRpc_1 = require("../client/jsonRpc");
+const date_1 = require("../helpers/date");
+const error_1 = require("../helpers/error");
+const formatter_1 = require("../helpers/formatter");
+const parse_1 = require("../helpers/parse");
+exports.searchCalendarCommand = new commander_1.Command('search')
+    .description('Search calendar events.')
+    .option('--last <days>', 'Show events from the last N days')
+    .option('--from <date>', 'Start date (YYYY-MM-DD)')
+    .option('--to <date>', 'End date (YYYY-MM-DD)')
+    .action(async (options) => {
+    try {
+        if (options.last && options.from) {
+            console.error(chalk_1.default.red('Cannot use --last and --from together.'));
+            process.exit(1);
+        }
+        const jsonMode = exports.searchCalendarCommand.parent?.parent?.opts().json ?? false;
+        const arguments_ = {
+            intent: 'Listing calendar events.',
+            pageIndex: 0,
+        };
+        if (options.last) {
+            arguments_['startDate'] = (0, date_1.getStartDateFromDaysAgo)((0, parse_1.parseIntOption)(options.last, '--last'));
+        }
+        else if (options.from) {
+            arguments_['startDate'] = options.from;
+        }
+        if (options.to)
+            arguments_['endDate'] = options.to;
+        const result = await (0, jsonRpc_1.callTool)('SearchCalendarEvents', arguments_);
+        (0, formatter_1.formatOutput)('SearchCalendarEvents', result, jsonMode);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Calendar search failed.';
+        console.error(chalk_1.default.red((0, error_1.formatMcpError)(message) ?? message));
+        process.exit(1);
+    }
+});

package/dist/commands/domains.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchDomainsCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const jsonRpc_1 = require("../client/jsonRpc");
+const error_1 = require("../helpers/error");
+const formatter_1 = require("../helpers/formatter");
+exports.searchDomainsCommand = new commander_1.Command('search')
+    .description('Search companies.')
+    .argument('<terms...>', 'Search terms for domains')
+    .action(async (terms) => {
+    try {
+        const jsonMode = exports.searchDomainsCommand.parent?.parent?.opts().json ?? false;
+        const result = await (0, jsonRpc_1.callTool)('FindDomains', {
+            searchTerms: terms,
+        });
+        (0, formatter_1.formatOutput)('FindDomains', result, jsonMode);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Company search failed.';
+        console.error(chalk_1.default.red((0, error_1.formatMcpError)(message) ?? message));
+        process.exit(1);
+    }
+});

package/dist/commands/emails.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchEmailsCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const jsonRpc_1 = require("../client/jsonRpc");
+const error_1 = require("../helpers/error");
+const formatter_1 = require("../helpers/formatter");
+const parse_1 = require("../helpers/parse");
+exports.searchEmailsCommand = new commander_1.Command('search')
+    .description('Search connected email accounts. Supports filters: from:email, to:email, participant:email, before:YYYY-MM-DD, after:YYYY-MM-DD.')
+    .argument('[search]', 'Search term')
+    .option('-p, --page <index>', 'Page index (starts at 0)', '0')
+    .action(async (query, options) => {
+    try {
+        if (query !== undefined && query.trim() === '') {
+            console.error(chalk_1.default.red('Search term cannot be empty.'));
+            process.exit(1);
+        }
+        const jsonMode = exports.searchEmailsCommand.parent?.parent?.opts().json ?? false;
+        const pageIndex = (0, parse_1.parseIntOption)(options.page, '--page');
+        const arguments_ = {
+            intent: query ?? 'Listing recent emails.',
+            pageIndex,
+        };
+        arguments_['searchTerm'] = query ?? '';
+        const result = await (0, jsonRpc_1.callTool)('SearchEmails', arguments_);
+        (0, formatter_1.formatOutput)('SearchEmails', result, jsonMode);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Email search failed.';
+        console.error(chalk_1.default.red((0, error_1.formatMcpError)(message) ?? message));
+        process.exit(1);
+    }
+});

package/dist/commands/meetings.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readMeetingsCommand = exports.searchMeetingsCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const jsonRpc_1 = require("../client/jsonRpc");
+const date_1 = require("../helpers/date");
+const error_1 = require("../helpers/error");
+const formatter_1 = require("../helpers/formatter");
+const parse_1 = require("../helpers/parse");
+const DEFAULT_MEETINGS_SEARCH_LAST_DAYS = 7;
+exports.searchMeetingsCommand = new commander_1.Command('search')
+    .description('Search for meetings.')
+    .argument('[search]', 'Search term')
+    .option('-p, --page <index>', 'Page index (starts at 0)', '0')
+    .option('--last <days>', 'Show meetings from the last N days')
+    .option('--from <date>', 'Start date (YYYY-MM-DD)')
+    .option('--to <date>', 'End date (YYYY-MM-DD)')
+    .option('--tags <ids>', 'Comma-separated tag IDs')
+    .option('--profiles <ids>', 'Comma-separated profile IDs')
+    .option('--domains <domains>', 'Comma-separated domains')
+    .action(async (query, options) => {
+    try {
+        if (options.last && options.from) {
+            console.error(chalk_1.default.red('Cannot use --last and --from together.'));
+            process.exit(1);
+        }
+        const jsonMode = exports.searchMeetingsCommand.parent?.parent?.opts().json ?? false;
+        const pageIndex = (0, parse_1.parseIntOption)(options.page, '--page');
+        const arguments_ = {
+            intent: query ?? 'Listing recent meetings.',
+            pageIndex,
+        };
+        if (query)
+            arguments_['searchTerm'] = query;
+        if (options.last) {
+            arguments_['startDate'] = (0, date_1.getStartDateFromDaysAgo)((0, parse_1.parseIntOption)(options.last, '--last'));
+        }
+        else if (options.from) {
+            arguments_['startDate'] = options.from;
+        }
+        else if (!query) {
+            arguments_['startDate'] = (0, date_1.getStartDateFromDaysAgo)(DEFAULT_MEETINGS_SEARCH_LAST_DAYS);
+        }
+        if (options.to)
+            arguments_['endDate'] = options.to;
+        if (options.tags)
+            arguments_['tags'] = (0, parse_1.parseNumericIds)(options.tags, 'tag ID');
+        if (options.profiles)
+            arguments_['profiles'] = (0, parse_1.parseNumericIds)(options.profiles, 'profile ID');
+        if (options.domains)
+            arguments_['domains'] = options.domains.split(',');
+        const result = await (0, jsonRpc_1.callTool)('SearchMeetings', arguments_);
+        (0, formatter_1.formatOutput)('SearchMeetings', result, jsonMode);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Search failed.';
+        console.error(chalk_1.default.red((0, error_1.formatMcpError)(message) ?? message));
+        process.exit(1);
+    }
+});
+exports.readMeetingsCommand = new commander_1.Command('read')
+    .description('Get detailed information for meetings.')
+    .argument('<ids…>', 'Meeting IDs')
+    .action(async (ids) => {
+    try {
+        const jsonMode = exports.readMeetingsCommand.parent?.parent?.opts().json ?? false;
+        const meetingIds = (0, parse_1.validateNumericIds)(ids, 'meeting ID');
+        const result = await (0, jsonRpc_1.callTool)('ReadMeetings', {
+            intent: `Reading meeting details for IDs: ${meetingIds.join(', ')}.`,
+            meetingIds,
+        });
+        (0, formatter_1.formatOutput)('ReadMeetings', result, jsonMode);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Read failed.';
+        console.error(chalk_1.default.red((0, error_1.formatMcpError)(message) ?? message));
+        process.exit(1);
+    }
+});