@parall/cli 1.12.0

package/dist/commands/agents.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerAgentCommands(program: Command): void;
+//# sourceMappingURL=agents.d.ts.map

package/dist/commands/agents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/commands/agents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,QAerD"}

package/dist/commands/agents.js

@@ -0,0 +1,18 @@
+import { resolveCredentials } from '../lib/client.js';
+import { printJson, printError } from '../lib/output.js';
+export function registerAgentCommands(program) {
+    const agents = program.command('agents').description('Manage agents');
+    agents
+        .command('list')
+        .description('List all agents in the organization')
+        .action(async () => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const result = await client.getAgents(orgId);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+}

package/dist/commands/chats.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerChatCommands(program: Command): void;
+//# sourceMappingURL=chats.d.ts.map

package/dist/commands/chats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chats.d.ts","sourceRoot":"","sources":["../../src/commands/chats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAsGpD"}

package/dist/commands/chats.js

@@ -0,0 +1,105 @@
+import { resolveCredentials } from '../lib/client.js';
+import { printJson, printError } from '../lib/output.js';
+export function registerChatCommands(program) {
+    const chats = program.command('chats').description('Manage chats');
+    chats
+        .command('list')
+        .description('List chats in the organization')
+        .option('--limit <n>', 'Maximum number of chats to return', '20')
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const params = { limit: Number(opts.limit) };
+            if (opts.cursor !== undefined)
+                params.cursor = opts.cursor;
+            const result = await client.getChats(orgId, params);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    chats
+        .command('get')
+        .description('Get a chat by ID')
+        .argument('<chatId>', 'Chat ID')
+        .action(async (chatId) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const result = await client.getChat(orgId, chatId);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    chats
+        .command('create')
+        .description('Create a new chat')
+        .requiredOption('--type <type>', 'Chat type: direct or group')
+        .requiredOption('--member-ids <ids>', 'Comma-separated member IDs')
+        .option('--name <name>', 'Chat name')
+        .option('--description <text>', 'Chat description')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const result = await client.createChat(orgId, {
+                type: opts.type,
+                member_ids: opts.memberIds.split(',').map((s) => s.trim()).filter(Boolean),
+                name: opts.name,
+                description: opts.description,
+            });
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    const members = chats.command('members').description('Manage chat members');
+    members
+        .command('list')
+        .description('List members of a chat')
+        .argument('<chatId>', 'Chat ID')
+        .action(async (chatId) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const result = await client.getChatMembers(orgId, chatId);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    members
+        .command('add')
+        .description('Add a member to a chat')
+        .argument('<chatId>', 'Chat ID')
+        .requiredOption('--user-id <userId>', 'User ID to add')
+        .option('--role <role>', 'Member role: owner, admin, or member', 'member')
+        .action(async (chatId, opts) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            await client.addChatMember(orgId, chatId, opts.userId, opts.role);
+            printJson({ ok: true });
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    members
+        .command('remove')
+        .description('Remove a member from a chat')
+        .argument('<chatId>', 'Chat ID')
+        .requiredOption('--user-id <userId>', 'User ID to remove')
+        .action(async (chatId, opts) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            await client.removeChatMember(orgId, chatId, opts.userId);
+            printJson({ ok: true });
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+}

package/dist/commands/dm.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerDMCommands(program: Command): void;
+//# sourceMappingURL=dm.d.ts.map

package/dist/commands/dm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dm.d.ts","sourceRoot":"","sources":["../../src/commands/dm.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2BpC,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,QA4BlD"}

package/dist/commands/dm.js

@@ -0,0 +1,51 @@
+import { resolveCredentials, resolveRuntimeContext } from '../lib/client.js';
+import { printJson, printError } from '../lib/output.js';
+/**
+ * Resolve a name-or-id argument to a user ID.
+ * If it starts with "usr_", treat as ID. Otherwise, search org members by display_name.
+ */
+async function resolveUserId(client, orgId, nameOrId) {
+    if (nameOrId.startsWith('usr_'))
+        return nameOrId;
+    const members = await client.getOrgMembers(orgId);
+    const matches = members.filter((m) => m.user?.display_name?.toLowerCase() === nameOrId.toLowerCase());
+    if (matches.length === 0) {
+        throw new Error(`No user found with display name "${nameOrId}"`);
+    }
+    if (matches.length > 1) {
+        const ids = matches.map((m) => `${m.user_id} (${m.user?.display_name})`).join(', ');
+        throw new Error(`Ambiguous name "${nameOrId}" matches multiple users: ${ids}`);
+    }
+    return matches[0].user_id;
+}
+export function registerDMCommands(program) {
+    program
+        .command('dm')
+        .description('Send a direct message to a user by name or ID (auto-creates chat if needed)')
+        .argument('<nameOrId>', 'Target user display name or ID (usr_...)')
+        .requiredOption('--text <text>', 'Message text')
+        .option('--no-reply', 'Hint that the recipient should not reply')
+        .action(async (nameOrId, opts) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const ctx = resolveRuntimeContext();
+            const userId = await resolveUserId(client, orgId, nameOrId);
+            const req = {
+                user_id: userId,
+                message_type: 'text',
+                content: { text: opts.text },
+            };
+            // Commander parses --no-reply as opts.reply = false
+            if (opts.reply === false) {
+                req.hints = { no_reply: true };
+            }
+            if (ctx.stepId)
+                req.agent_step_id = ctx.stepId;
+            const result = await client.sendDirectMessage(orgId, req);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+}

package/dist/commands/mcp.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerMcpCommands(program: Command): void;
+//# sourceMappingURL=mcp.d.ts.map

package/dist/commands/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/commands/mcp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmBpC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,QA6bnD"}

package/dist/commands/mcp.js

@@ -0,0 +1,439 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import * as z from 'zod/v4';
+import { resolveCredentials } from '../lib/client.js';
+import { getWikiBlob, getWikiChangesetDiff, getWikiOutline, queryWiki, getWikiSection, getWikiTree, getWikiWorkspaceDiff, getWikiWorkspaceStatus, listWikis, proposeWikiChangeset, searchWiki, } from '../lib/wiki.js';
+export function registerMcpCommands(program) {
+    program
+        .command('mcp')
+        .description('Run a Parall MCP server over stdio')
+        .action(async () => {
+        const ctx = resolveCredentials();
+        const server = new McpServer({
+            name: 'parall-mcp',
+            version: '1.0.0',
+        });
+        server.registerTool('wiki_list', {
+            title: 'List Parall Wikis',
+            description: 'List Parall wiki repositories that the current credentials can access.',
+            annotations: {
+                readOnlyHint: true,
+            },
+            outputSchema: {
+                wikis: z.array(z.object({
+                    id: z.string(),
+                    slug: z.string(),
+                    name: z.string(),
+                    default_branch: z.string(),
+                })),
+            },
+        }, async () => {
+            const wikis = await listWikis(ctx);
+            const structuredContent = {
+                wikis: wikis.map((wiki) => ({
+                    id: wiki.id,
+                    slug: wiki.slug,
+                    name: wiki.name,
+                    default_branch: wiki.default_branch,
+                })),
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(structuredContent, null, 2) }],
+                structuredContent,
+            };
+        });
+        server.registerTool('wiki_tree', {
+            title: 'Browse Wiki Tree',
+            description: 'List files and folders under a Parall wiki path.',
+            annotations: {
+                readOnlyHint: true,
+            },
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                path: z.string().optional().describe('Optional tree path prefix inside the wiki'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                path: z.string(),
+                entries: z.array(z.object({
+                    name: z.string(),
+                    path: z.string(),
+                    type: z.enum(['tree', 'blob']),
+                    size: z.number().optional(),
+                })),
+            },
+        }, async ({ wiki, path }) => {
+            const result = await getWikiTree(ctx, wiki, { path });
+            const structuredContent = {
+                wiki_id: result.wiki.id,
+                wiki_slug: result.wiki.slug,
+                wiki_name: result.wiki.name,
+                path: result.path,
+                entries: result.entries,
+            };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(structuredContent, null, 2) }],
+                structuredContent,
+            };
+        });
+        server.registerTool('wiki_status', {
+            title: 'Inspect Wiki Workspace Status',
+            description: 'Inspect the current local mounted wiki workspace before proposing changes.',
+            annotations: {
+                readOnlyHint: true,
+            },
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                mount_path: z.string(),
+                mode: z.enum(['read_only', 'read_write']),
+                default_ref: z.string(),
+                changed_paths: z.array(z.string()),
+                diff_files: z.array(z.object({
+                    path: z.string(),
+                    additions: z.number(),
+                    deletions: z.number(),
+                })),
+                dirty: z.boolean(),
+                source: z.literal('local_mount'),
+            },
+        }, async ({ wiki }) => {
+            const result = await getWikiWorkspaceStatus(ctx, wiki);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                structuredContent: result,
+            };
+        });
+        server.registerTool('wiki_diff', {
+            title: 'Read Wiki Workspace Diff',
+            description: 'Read the current unified diff for a local mounted wiki workspace.',
+            annotations: {
+                readOnlyHint: true,
+            },
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                mount_path: z.string(),
+                changed_paths: z.array(z.string()),
+                diff_files: z.array(z.object({
+                    path: z.string(),
+                    additions: z.number(),
+                    deletions: z.number(),
+                })),
+                patch: z.string(),
+                source: z.literal('local_mount'),
+            },
+        }, async ({ wiki }) => {
+            const result = await getWikiWorkspaceDiff(ctx, wiki);
+            return {
+                content: [{ type: 'text', text: result.patch || JSON.stringify(result, null, 2) }],
+                structuredContent: result,
+            };
+        });
+        server.registerTool('wiki_blob', {
+            title: 'Read Wiki File',
+            description: 'Read a file from a Parall wiki and return its text content.',
+            annotations: {
+                readOnlyHint: true,
+            },
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                path: z.string().describe('File path inside the wiki'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                content: z.string(),
+                sha256: z.string(),
+                size: z.number(),
+            },
+        }, async ({ wiki, path }) => {
+            const result = await getWikiBlob(ctx, wiki, { path });
+            const structuredContent = {
+                wiki_id: result.wiki.id,
+                wiki_slug: result.wiki.slug,
+                wiki_name: result.wiki.name,
+                content: result.content,
+                size: result.size,
+            };
+            return {
+                content: [{ type: 'text', text: result.content || JSON.stringify(structuredContent, null, 2) }],
+                structuredContent,
+            };
+        });
+        server.registerTool('wiki_search', {
+            title: 'Search Wiki Markdown',
+            description: 'Search Markdown headings and section bodies inside a Parall wiki. Prefers local mounts when no ref is supplied and agent env is available; otherwise falls back to the Parall API.',
+            annotations: {
+                readOnlyHint: true,
+            },
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                query: z.string().describe('Search query'),
+                ref: z.string().optional().describe('Optional git ref for API-backed search'),
+                path_prefix: z.string().optional().describe('Restrict search to a file or directory path prefix'),
+                limit: z.number().int().positive().max(20).optional().describe('Maximum number of results; default 5'),
+                include_content: z.boolean().optional().describe('Include full matched section content in each result'),
+            },
+            outputSchema: {
+                results: z.array(z.object({
+                    wiki_id: z.string(),
+                    wiki_slug: z.string(),
+                    wiki_name: z.string(),
+                    node_id: z.string(),
+                    path: z.string(),
+                    title: z.string(),
+                    heading_path: z.array(z.string()).optional(),
+                    section_path: z.string(),
+                    level: z.number(),
+                    start_line: z.number(),
+                    end_line: z.number(),
+                    score: z.number(),
+                    snippet: z.string(),
+                    content: z.string().optional(),
+                    source: z.enum(['local_mount', 'api']),
+                })),
+            },
+        }, async ({ wiki, query, ref, path_prefix: pathPrefix, limit, include_content: includeContent }) => {
+            const results = await searchWiki(ctx, wiki, query, {
+                ref,
+                pathPrefix,
+                limit,
+                includeContent,
+            });
+            const structuredContent = { results };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(structuredContent, null, 2) }],
+                structuredContent,
+            };
+        });
+        server.registerTool('wiki_query', {
+            title: 'Query Wiki Structurally',
+            description: 'Run a tree-aware wiki query that first narrows candidate documents and then selects the best sections.',
+            annotations: {
+                readOnlyHint: true,
+            },
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                query: z.string().describe('Natural-language query'),
+                ref: z.string().optional().describe('Optional git ref for API-backed queries'),
+                path_prefix: z.string().optional().describe('Restrict the query to a file or directory path prefix'),
+                limit: z.number().int().positive().max(20).optional().describe('Maximum number of section results; default 5'),
+                include_content: z.boolean().optional().describe('Include full matched section content in each result'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                query: z.string(),
+                ref: z.string().optional(),
+                path_prefix: z.string().optional(),
+                generated_at: z.string(),
+                file_count: z.number(),
+                source: z.enum(['local_mount', 'api']),
+                documents: z.array(z.object({
+                    path: z.string(),
+                    title: z.string(),
+                    score: z.number(),
+                    matched_headings: z.array(z.string()),
+                    node_count: z.number(),
+                })),
+                sections: z.array(z.object({
+                    wiki_id: z.string(),
+                    wiki_slug: z.string(),
+                    wiki_name: z.string(),
+                    node_id: z.string(),
+                    path: z.string(),
+                    title: z.string(),
+                    heading_path: z.array(z.string()).optional(),
+                    section_path: z.string(),
+                    level: z.number(),
+                    start_line: z.number(),
+                    end_line: z.number(),
+                    score: z.number(),
+                    document_score: z.number(),
+                    snippet: z.string(),
+                    content: z.string().optional(),
+                    source: z.enum(['local_mount', 'api']),
+                    reasoning: z.array(z.string()),
+                })),
+            },
+        }, async ({ wiki, query, ref, path_prefix: pathPrefix, limit, include_content: includeContent }) => {
+            const result = await queryWiki(ctx, wiki, query, {
+                ref,
+                pathPrefix,
+                limit,
+                includeContent,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                structuredContent: result,
+            };
+        });
+        server.registerTool('wiki_outline', {
+            title: 'Read Wiki Outline',
+            description: 'Return the structural node outline for a Parall wiki or a path prefix within it.',
+            annotations: {
+                readOnlyHint: true,
+            },
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                ref: z.string().optional().describe('Optional git ref for API-backed outline'),
+                path_prefix: z.string().optional().describe('Restrict outline to a file or directory path prefix'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                ref: z.string().optional(),
+                path_prefix: z.string().optional(),
+                generated_at: z.string(),
+                file_count: z.number(),
+                source: z.enum(['local_mount', 'api']),
+                nodes: z.array(z.object({
+                    wiki_id: z.string(),
+                    wiki_slug: z.string(),
+                    wiki_name: z.string(),
+                    node_id: z.string(),
+                    path: z.string(),
+                    title: z.string(),
+                    heading_path: z.array(z.string()).optional(),
+                    section_path: z.string(),
+                    level: z.number(),
+                    start_line: z.number(),
+                    end_line: z.number(),
+                })),
+            },
+        }, async ({ wiki, ref, path_prefix: pathPrefix }) => {
+            const outline = await getWikiOutline(ctx, wiki, { ref, pathPrefix });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(outline, null, 2) }],
+                structuredContent: outline,
+            };
+        });
+        server.registerTool('wiki_section', {
+            title: 'Read Wiki Section',
+            description: 'Read a specific Markdown section from a Parall wiki by node ID. Node IDs come from `wiki_search` results.',
+            annotations: {
+                readOnlyHint: true,
+            },
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                node_id: z.string().describe('Section node ID returned by wiki_search'),
+                ref: z.string().optional().describe('Optional git ref; when set, reads from the Parall API instead of a local mount'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                node_id: z.string(),
+                path: z.string(),
+                title: z.string(),
+                heading_path: z.array(z.string()).optional(),
+                section_path: z.string(),
+                level: z.number(),
+                start_line: z.number(),
+                end_line: z.number(),
+                content: z.string(),
+                source: z.enum(['local_mount', 'api']),
+            },
+        }, async ({ wiki, node_id: nodeId, ref }) => {
+            const section = await getWikiSection(ctx, wiki, { nodeId, ref });
+            return {
+                content: [{ type: 'text', text: section.content || JSON.stringify(section, null, 2) }],
+                structuredContent: section,
+            };
+        });
+        server.registerTool('wiki_changeset_diff', {
+            title: 'Read Wiki Changeset Diff',
+            description: 'Fetch the unified diff and changed file summary for a Parall wiki changeset.',
+            annotations: {
+                readOnlyHint: true,
+            },
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                changeset_id: z.string().describe('Wiki changeset ID'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                changeset_id: z.string(),
+                diff: z.object({
+                    patch: z.string(),
+                    files: z.array(z.object({
+                        path: z.string(),
+                        additions: z.number(),
+                        deletions: z.number(),
+                    })),
+                }),
+            },
+        }, async ({ wiki, changeset_id: changesetId }) => {
+            const diff = await getWikiChangesetDiff(ctx, wiki, changesetId);
+            return {
+                content: [{ type: 'text', text: diff.diff.patch || JSON.stringify(diff, null, 2) }],
+                structuredContent: diff,
+            };
+        });
+        server.registerTool('wiki_propose', {
+            title: 'Propose Wiki Changeset',
+            description: 'Create or update a proposed wiki changeset from the current local mounted wiki workspace.',
+            inputSchema: {
+                wiki: z.string().describe('Wiki slug or ID'),
+                title: z.string().min(1).describe('Changeset title'),
+                message: z.string().optional().describe('Changeset commit message (supports prll:// refs)'),
+                changeset_id: z.string().optional().describe('Existing changeset ID to update'),
+                source_chat_id: z.string().optional().describe('Optional source chat ID for approval workflow linkage'),
+                source_message_id: z.string().optional().describe('Optional source message ID for approval workflow linkage'),
+                source_run_id: z.string().optional().describe('Optional source run ID for approval workflow linkage'),
+            },
+            outputSchema: {
+                wiki_id: z.string(),
+                wiki_slug: z.string(),
+                wiki_name: z.string(),
+                mount_path: z.string(),
+                changed_paths: z.array(z.string()),
+                diff_files: z.array(z.object({
+                    path: z.string(),
+                    additions: z.number(),
+                    deletions: z.number(),
+                })),
+                source: z.literal('local_mount'),
+                changeset: z.object({
+                    id: z.string(),
+                    wiki_id: z.string(),
+                    title: z.string(),
+                    status: z.string(),
+                    changed_paths: z.array(z.string()).optional(),
+                }).passthrough(),
+            },
+        }, async ({ wiki, title, message, changeset_id: changesetId, source_chat_id: sourceChatId, source_message_id: sourceMessageId, source_run_id: sourceRunId }) => {
+            const result = await proposeWikiChangeset(ctx, wiki, {
+                title,
+                message,
+                changesetId,
+                sourceChatId,
+                sourceMessageId,
+                sourceRunId,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                structuredContent: result,
+            };
+        });
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        console.error('parall MCP server running on stdio');
+    });
+}

package/dist/commands/messages.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerMessageCommands(program: Command): void;
+//# sourceMappingURL=messages.d.ts.map

package/dist/commands/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/commands/messages.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,QAiGvD"}