@iamcoder18/huly-cli 0.1.0

package/dist/resources/channel.js

@@ -0,0 +1,709 @@
+import pkg from '@hcengineering/api-client';
+const { MarkupContent } = pkg;
+import { connectCli, connectAccountCli } from '../transport/sdk.js';
+import { resolveRef, buildIndex, invalidateIndex } from '../transport/ref-resolver.js';
+import { shouldJson, json, table, COLUMNS, C, success, updated, bulkRemoved } from "../output/format.js";
+import { withSpinner } from '../output/progress.js';
+import { CliError, ExitCode } from '../output/errors.js';
+import { readEnv } from '../auth/env.js';
+const CHANNEL_CLASS = 'chunter:class:Channel';
+const CHAT_MESSAGE_CLASS = 'chunter:class:ChatMessage';
+const DM_CLASS = 'chunter:class:DirectMessage';
+async function resolveChannel(client, ref) {
+    const account = await client.getAccount();
+    const idx = await buildIndex(client, CHANNEL_CLASS, account.uuid);
+    const hit = idx.get(ref);
+    if (hit) {
+        const doc = await client.findOne(CHANNEL_CLASS, { _id: hit });
+        if (doc)
+            return doc;
+    }
+    // try by name
+    const all = (await client.findAll(CHANNEL_CLASS, {}));
+    const byName = all.find((c) => c.name === ref);
+    if (byName)
+        return byName;
+    throw new CliError(ExitCode.NotFound, `channel ${ref} not found`);
+}
+async function resolvePersonId(emailOrName, client, opts = {}) {
+    // Strategy 1: scan workspace-local Person docs (works for multi-user
+    // selfhosts and production workspaces where each user has a
+    // contact:class:Person doc).
+    const lower = emailOrName.toLowerCase();
+    try {
+        const persons = (await client.findAll('contact:class:Person', {}, { limit: 200 }));
+        const hit = persons.find((p) => {
+            const n = String(p.name ?? '').toLowerCase();
+            const e = String(p.email ?? '').toLowerCase();
+            return n === lower || n.startsWith(lower) || n.includes(lower) || e === lower;
+        });
+        if (hit)
+            return hit._id;
+    }
+    catch {
+        // model may not know about contact:class:Person — fall through
+    }
+    // Strategy 2: ask the account service for workspace members. The
+    // account client returns person UUIDs for each member regardless of
+    // whether a contact:class:Person doc was created in the workspace.
+    try {
+        const env = readEnv();
+        const accountClient = await connectAccountCli({ url: opts.url ?? env.url, workspace: opts.workspace ?? env.workspace });
+        const members = await accountClient.getWorkspaceMembers();
+        if (members.length > 0) {
+            const me = await accountClient.getPerson().catch(() => null);
+            const myUuid = me?.uuid;
+            if (emailOrName.includes('@')) {
+                const socialId = await accountClient.findSocialIdBySocialKey(emailOrName).catch(() => undefined);
+                if (socialId !== undefined) {
+                    const person = await accountClient.findPersonBySocialId(socialId, true).catch(() => undefined);
+                    if (person !== undefined)
+                        return person;
+                }
+            }
+            // If the caller passed a raw UUID (36-char hex), use it directly.
+            if (/^[0-9a-f-]{36}$/i.test(emailOrName)) {
+                return emailOrName;
+            }
+            // Last resort: if the workspace has exactly one other member and
+            // the caller passed a non-empty identifier, return that member's
+            // person UUID.
+            const otherMembers = members.filter((m) => m.person !== myUuid);
+            if (otherMembers.length === 1)
+                return otherMembers[0].person;
+            if (otherMembers.length === 0) {
+                throw new CliError(ExitCode.NotFound, `no other person in this workspace — you are the only member`, 'a DM requires at least one other member; invite someone via `huly user invite <email>`');
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof CliError)
+            throw err;
+        // account service unreachable or returned Forbidden — fall through
+    }
+    throw new CliError(ExitCode.NotFound, `no person matching ${emailOrName}`, 'try --members <uuid1> <uuid2> with raw account UUIDs instead of --person');
+}
+// ---- list / get / create / update / delete ----
+export async function listChannels(opts = {}) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const query = {};
+        if (opts.archived !== undefined)
+            query.archived = opts.archived;
+        const docs = (await withSpinner('Loading channels…', () => client.findAll(CHANNEL_CLASS, query), opts));
+        let r = docs;
+        if (opts.offset && opts.offset > 0)
+            r = r.slice(opts.offset);
+        if (opts.limit && opts.limit > 0)
+            r = r.slice(0, opts.limit);
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json(r);
+            return;
+        }
+        table(r, COLUMNS.channel(), { count: true, title: 'channels' });
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function getChannel(ref, opts) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channel = await resolveChannel(client, ref);
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json(channel);
+            return;
+        }
+        table([channel], COLUMNS.channel());
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function createChannel(opts) {
+    if (!opts.name)
+        throw new CliError(ExitCode.Validation, 'missing --name');
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const account = await client.getAccount();
+        const memberIds = [];
+        if (opts.members && opts.members.length > 0) {
+            for (const m of opts.members)
+                memberIds.push(await resolvePersonId(m, client));
+        }
+        memberIds.unshift(account.uuid);
+        const data = {
+            name: opts.name,
+            description: opts.description ?? '',
+            topic: opts.topic ?? '',
+            private: opts.private ?? false,
+            archived: false,
+            members: memberIds,
+            owners: [account.uuid],
+            autoJoin: opts.autoJoin ?? false,
+            autoJoinForRoles: []
+        };
+        if (opts.dryRun) {
+            console.log('would create channel:');
+            console.log(JSON.stringify({ _class: CHANNEL_CLASS, space: 'chunter:space:Chunter', data }, null, 2));
+            return;
+        }
+        const id = await withSpinner('Creating channel…', () => client.createDoc(CHANNEL_CLASS, 'chunter:space:Chunter', data), opts);
+        invalidateIndex(account.uuid, CHANNEL_CLASS);
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json({ _id: id, ...data });
+            return;
+        }
+        success(`created channel`, id);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function updateChannel(ref, opts) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channel = await resolveChannel(client, ref);
+        const ops = {};
+        if (opts.name)
+            ops.name = opts.name;
+        if (opts.description !== undefined)
+            ops.description = opts.description;
+        if (opts.topic !== undefined)
+            ops.topic = opts.topic;
+        if (opts.private !== undefined)
+            ops.private = opts.private;
+        if (opts.autoJoin !== undefined)
+            ops.autoJoin = opts.autoJoin;
+        if (Object.keys(ops).length === 0)
+            throw new CliError(ExitCode.Validation, 'nothing to update', 'pass --name/--description/--topic/--private/--auto-join');
+        if (opts.dryRun) {
+            console.log(`would update channel ${channel._id}:`);
+            console.log(JSON.stringify({ _class: CHANNEL_CLASS, objectId: channel._id, ops }, null, 2));
+            return;
+        }
+        await withSpinner('Updating…', () => client.updateDoc(CHANNEL_CLASS, channel.space, channel._id, ops), opts);
+        updated(`updated channel`, channel._id);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function deleteChannels(refs, opts = {}) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channels = [];
+        for (const r of refs) {
+            try {
+                channels.push(await resolveChannel(client, r));
+            }
+            catch (e) {
+                if (e instanceof CliError)
+                    throw e;
+                throw new CliError(ExitCode.NotFound, `channel ${r} not found`);
+            }
+        }
+        if (!opts.yes && channels.length > 1) {
+            throw new CliError(ExitCode.Validation, `destructive: deleting ${channels.length} channels requires --yes`, 're-run with --yes to confirm');
+        }
+        let deleted = 0, skipped = 0;
+        for (const ch of channels) {
+            try {
+                await client.removeDoc(CHANNEL_CLASS, ch.space, ch._id);
+                deleted++;
+            }
+            catch (e) {
+                console.error(`failed to delete ${ch._id}: ${e.message}`);
+                skipped++;
+            }
+        }
+        bulkRemoved(deleted, skipped);
+    }
+    finally {
+        await client.close();
+    }
+}
+// ---- archive / unarchive ----
+export async function archiveChannel(ref, opts = {}) {
+    const archive = opts.value ?? true;
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channel = await resolveChannel(client, ref);
+        if (opts.dryRun) {
+            console.log(`would set archived=${archive} on ${channel._id}`);
+            return;
+        }
+        await withSpinner('Archiving…', () => client.updateDoc(CHANNEL_CLASS, channel.space, channel._id, { archived: archive }));
+        console.log(C.info(`archived channel`) + C.muted('  ') + C.emphasis(`${channel._id} archived=${archive}`));
+    }
+    finally {
+        await client.close();
+    }
+}
+// ---- members ----
+export async function listChannelMembers(ref, opts) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channel = await resolveChannel(client, ref);
+        const members = channel.members ?? [];
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json(members);
+            return;
+        }
+        table(members.map((m) => ({ uuid: m })), [
+            { key: 'uuid', header: 'UUID' }
+        ], { count: true, title: 'members' });
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function joinChannel(ref, opts = {}) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const account = await client.getAccount();
+        const channel = await resolveChannel(client, ref);
+        const memberId = opts.member ? await resolvePersonId(opts.member, client) : account.uuid;
+        if (channel.members?.includes(memberId)) {
+            console.log('(already a member)');
+            return;
+        }
+        if (opts.dryRun) {
+            console.log(`would join ${memberId} to channel ${channel._id}`);
+            return;
+        }
+        await withSpinner('Joining…', () => client.updateDoc(CHANNEL_CLASS, channel.space, channel._id, {
+            $push: { members: { $each: [memberId], $position: 0 } }
+        }));
+        success(`joined member`, `${memberId} → ${channel._id}`);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function leaveChannel(ref, opts = {}) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const account = await client.getAccount();
+        const channel = await resolveChannel(client, ref);
+        const memberId = opts.member ? await resolvePersonId(opts.member, client) : account.uuid;
+        if (!channel.members?.includes(memberId)) {
+            console.log('(not a member)');
+            return;
+        }
+        if (opts.dryRun) {
+            console.log(`would remove ${memberId} from channel ${channel._id}`);
+            return;
+        }
+        await withSpinner('Leaving…', () => client.updateDoc(CHANNEL_CLASS, channel.space, channel._id, {
+            $pull: { members: { $in: [memberId] } }
+        }));
+        success(`removed member`, `${memberId} from ${channel._id}`);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function addChannelMembers(ref, members, opts = {}) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channel = await resolveChannel(client, ref);
+        const ids = [];
+        for (const m of members)
+            ids.push(await resolvePersonId(m, client));
+        if (opts.dryRun) {
+            console.log(`would add ${ids.length} members to channel ${channel._id}`);
+            return;
+        }
+        await withSpinner('Adding members…', () => client.updateDoc(CHANNEL_CLASS, channel.space, channel._id, {
+            $push: { members: { $each: ids, $position: 0 } }
+        }));
+        console.log(C.ok(`added ${ids.length} members`) + C.muted('  ') + C.emphasis(`to ${channel._id}`));
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function removeChannelMembers(ref, members, opts = {}) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channel = await resolveChannel(client, ref);
+        const ids = [];
+        for (const m of members)
+            ids.push(await resolvePersonId(m, client));
+        if (opts.dryRun) {
+            console.log(`would remove ${ids.length} members from channel ${channel._id}`);
+            return;
+        }
+        await withSpinner('Removing members…', () => client.updateDoc(CHANNEL_CLASS, channel.space, channel._id, {
+            $pull: { members: { $in: ids } }
+        }));
+        success(`removed ${ids.length} members`, `from ${channel._id}`);
+    }
+    finally {
+        await client.close();
+    }
+}
+// ---- messages ----
+export async function listChannelMessages(ref, opts) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channel = await resolveChannel(client, ref);
+        const messages = (await withSpinner('Loading messages…', () => client.findAll(CHAT_MESSAGE_CLASS, {
+            attachedTo: channel._id,
+            attachedToClass: CHANNEL_CLASS,
+            collection: 'messages'
+        }), opts));
+        let r = messages;
+        if (opts.offset && opts.offset > 0)
+            r = r.slice(opts.offset);
+        if (opts.limit && opts.limit > 0)
+            r = r.slice(0, opts.limit);
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json(r);
+            return;
+        }
+        table(r, COLUMNS.channelMessage(), { count: true, title: 'messages' });
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function sendChannelMessage(ref, opts) {
+    const body = await readMessageBody(opts);
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channel = await resolveChannel(client, ref);
+        const data = {
+            message: body
+        };
+        if (opts.dryRun) {
+            console.log('would send channel message:');
+            console.log(JSON.stringify({ _class: CHAT_MESSAGE_CLASS, space: channel.space, attachedTo: channel._id, attachedToClass: CHANNEL_CLASS, collection: 'messages', data }, null, 2));
+            return;
+        }
+        const id = await withSpinner('Sending…', () => client.addCollection(CHAT_MESSAGE_CLASS, channel.space, channel._id, CHANNEL_CLASS, 'messages', data));
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json({ _id: id, ...data });
+            return;
+        }
+        console.log(`sent: ${id}`);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function updateChannelMessage(ref, messageId, opts) {
+    const body = await readMessageBody(opts);
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channel = await resolveChannel(client, ref);
+        const msg = await client.findOne(CHAT_MESSAGE_CLASS, { _id: messageId });
+        if (!msg)
+            throw new CliError(ExitCode.NotFound, `message ${messageId} not found`);
+        if (msg.attachedTo !== channel._id) {
+            throw new CliError(ExitCode.NotFound, 'message does not belong to this channel');
+        }
+        const data = {
+            message: body,
+            editedOn: Date.now()
+        };
+        if (opts.dryRun) {
+            console.log(`would update message ${messageId}:`);
+            console.log(JSON.stringify({ _class: CHAT_MESSAGE_CLASS, space: msg.space, ops: data }, null, 2));
+            return;
+        }
+        await withSpinner('Updating…', () => client.updateCollection(CHAT_MESSAGE_CLASS, msg.space, messageId, channel._id, CHANNEL_CLASS, 'messages', data));
+        updated(`updated message`, messageId);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function deleteChannelMessages(ref, messageIds, opts = {}) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const channel = await resolveChannel(client, ref);
+        if (!opts.yes && messageIds.length > 1) {
+            throw new CliError(ExitCode.Validation, `destructive: deleting ${messageIds.length} messages requires --yes`, 're-run with --yes to confirm');
+        }
+        let deleted = 0, skipped = 0;
+        for (const id of messageIds) {
+            const msg = await client.findOne(CHAT_MESSAGE_CLASS, { _id: id });
+            if (!msg) {
+                skipped++;
+                continue;
+            }
+            if (msg.attachedTo !== channel._id) {
+                console.error(`skipped: ${id} (message does not belong to this channel)`);
+                skipped++;
+                continue;
+            }
+            try {
+                await client.removeCollection(CHAT_MESSAGE_CLASS, msg.space, id, channel._id, CHANNEL_CLASS, 'messages');
+                deleted++;
+            }
+            catch (e) {
+                console.error(`failed: ${id}: ${e.message}`);
+                skipped++;
+            }
+        }
+        bulkRemoved(deleted, skipped);
+    }
+    finally {
+        await client.close();
+    }
+}
+// ---- threads ----
+export async function listThreadReplies(targetId, opts) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const replies = (await client.findAll('chunter:class:ThreadMessage', { attachedTo: targetId }));
+        let r = replies;
+        if (opts.offset && opts.offset > 0)
+            r = r.slice(opts.offset);
+        if (opts.limit && opts.limit > 0)
+            r = r.slice(0, opts.limit);
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json(r);
+            return;
+        }
+        table(r, COLUMNS.channelMessage(), { count: true, title: 'messages' });
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function addThreadReply(targetId, opts) {
+    const body = await readMessageBody(opts);
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const parent = await client.findOne(CHAT_MESSAGE_CLASS, { _id: targetId });
+        if (!parent)
+            throw new CliError(ExitCode.NotFound, `target message ${targetId} not found`);
+        const data = {
+            message: body
+        };
+        if (opts.dryRun) {
+            console.log('would add thread reply:');
+            console.log(JSON.stringify({ _class: 'chunter:class:ThreadMessage', space: parent.space, attachedTo: targetId, data }, null, 2));
+            return;
+        }
+        const id = await withSpinner('Adding reply…', () => client.addCollection('chunter:class:ThreadMessage', parent.space, targetId, CHAT_MESSAGE_CLASS, 'replies', data));
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json({ _id: id, ...data });
+            return;
+        }
+        success(`added reply`, id);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function updateThreadReply(replyId, opts) {
+    const body = await readMessageBody(opts);
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const reply = await client.findOne('chunter:class:ThreadMessage', { _id: replyId });
+        if (!reply)
+            throw new CliError(ExitCode.NotFound, `thread reply ${replyId} not found`);
+        const data = { message: body, editedOn: Date.now() };
+        if (opts.dryRun) {
+            console.log(`would update thread reply ${replyId}:`);
+            console.log(JSON.stringify({ _class: 'chunter:class:ThreadMessage', space: reply.space, ops: data }, null, 2));
+            return;
+        }
+        await withSpinner('Updating…', () => client.updateCollection('chunter:class:ThreadMessage', reply.space, replyId, reply.attachedTo, CHAT_MESSAGE_CLASS, 'replies', data));
+        updated(`updated reply`, replyId);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function deleteThreadReplies(replyIds, opts = {}) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        if (!opts.yes && replyIds.length > 1) {
+            throw new CliError(ExitCode.Validation, `destructive: deleting ${replyIds.length} replies requires --yes`, 're-run with --yes to confirm');
+        }
+        let deleted = 0, skipped = 0;
+        for (const id of replyIds) {
+            const reply = await client.findOne('chunter:class:ThreadMessage', { _id: id });
+            if (!reply) {
+                skipped++;
+                continue;
+            }
+            try {
+                await client.removeCollection('chunter:class:ThreadMessage', reply.space, id, reply.attachedTo, CHAT_MESSAGE_CLASS, 'replies');
+                deleted++;
+            }
+            catch (e) {
+                console.error(`failed: ${id}: ${e.message}`);
+                skipped++;
+            }
+        }
+        bulkRemoved(deleted, skipped);
+    }
+    finally {
+        await client.close();
+    }
+}
+// ---- DMs ----
+export async function listDms(opts = {}) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const dms = (await withSpinner('Loading DMs…', () => client.findAll(DM_CLASS, {}), opts));
+        let r = dms;
+        if (opts.offset && opts.offset > 0)
+            r = r.slice(opts.offset);
+        if (opts.limit && opts.limit > 0)
+            r = r.slice(0, opts.limit);
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json(r);
+            return;
+        }
+        table(r, [
+            { key: 'name', header: 'NAME' },
+            { key: 'description', header: 'DESCRIPTION' },
+            { key: '_id', header: '_ID', format: (r) => String(r._id).slice(-12) }
+        ]);
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function createDm(opts) {
+    if (!opts.person && (!opts.members || opts.members.length === 0)) {
+        throw new CliError(ExitCode.Validation, 'missing --person or --members');
+    }
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const account = await client.getAccount();
+        const memberIds = [];
+        if (opts.person)
+            memberIds.push(await resolvePersonId(opts.person, client, { url: opts.url, workspace: opts.workspace }));
+        if (opts.members) {
+            for (const m of opts.members)
+                memberIds.push(await resolvePersonId(m, client, { url: opts.url, workspace: opts.workspace }));
+        }
+        memberIds.unshift(account.uuid);
+        const data = {
+            name: '',
+            description: '',
+            members: memberIds,
+            pinned: false
+        };
+        if (opts.dryRun) {
+            console.log('would create DM:');
+            console.log(JSON.stringify({ _class: DM_CLASS, space: 'chunter:space:Chunter', data }, null, 2));
+            return undefined;
+        }
+        const id = await withSpinner('Creating DM…', () => client.createDoc(DM_CLASS, 'chunter:space:Chunter', data), opts);
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json({ _id: id, ...data });
+            return undefined;
+        }
+        success('created DM', id);
+        return id;
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function listDmMessages(dmRef, opts) {
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const account = await client.getAccount();
+        const dmId = await resolveRef(dmRef, {
+            client,
+            classId: DM_CLASS,
+            workspaceId: account.uuid
+        });
+        const messages = (await withSpinner('Loading DM messages…', () => client.findAll(CHAT_MESSAGE_CLASS, {
+            attachedTo: dmId,
+            attachedToClass: DM_CLASS,
+            collection: 'messages'
+        }), opts));
+        let r = messages;
+        if (opts.offset && opts.offset > 0)
+            r = r.slice(opts.offset);
+        if (opts.limit && opts.limit > 0)
+            r = r.slice(0, opts.limit);
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json(r);
+            return;
+        }
+        table(r, COLUMNS.channelMessage(), { count: true, title: 'messages' });
+    }
+    finally {
+        await client.close();
+    }
+}
+export async function sendDmMessage(dmRef, opts) {
+    const body = await readMessageBody(opts);
+    // --person <email>: resolve or auto-create DM, then send.
+    if (opts.person !== undefined && opts.person !== '') {
+        // CLI-04: forward --dry-run so createDm doesn't actually mutate state
+        // and emit a preview instead.
+        const dmId = await createDm({
+            person: opts.person,
+            dryRun: opts.dryRun,
+            workspace: opts.workspace,
+            url: opts.url
+        });
+        if (opts.dryRun) {
+            console.log('would send DM:');
+            console.log(JSON.stringify({
+                wouldCreateDm: { person: opts.person },
+                wouldSendTo: dmRef,
+                message: body
+            }, null, 2));
+            return;
+        }
+        if (dmId !== undefined)
+            dmRef = String(dmId);
+    }
+    const client = await connectCli({ url: opts.url, workspace: opts.workspace });
+    try {
+        const account = await client.getAccount();
+        const dmId = await resolveRef(dmRef, {
+            client,
+            classId: DM_CLASS,
+            workspaceId: account.uuid
+        });
+        const dm = await client.findOne(DM_CLASS, { _id: dmId });
+        if (!dm)
+            throw new CliError(ExitCode.NotFound, `DM ${dmRef} not found`);
+        const data = { message: body };
+        if (opts.dryRun) {
+            console.log('would send DM:');
+            console.log(JSON.stringify({ _class: CHAT_MESSAGE_CLASS, space: dm.space, attachedTo: dmId, attachedToClass: DM_CLASS, collection: 'messages', data }, null, 2));
+            return;
+        }
+        const id = await withSpinner('Sending…', () => client.addCollection(CHAT_MESSAGE_CLASS, dm.space, dmId, DM_CLASS, 'messages', data));
+        if (shouldJson({ json: opts.json, ci: opts.ci })) {
+            json({ _id: id, ...data });
+            return;
+        }
+        console.log(`sent: ${id}`);
+    }
+    finally {
+        await client.close();
+    }
+}
+// ---- helpers ----
+async function readMessageBody(opts) {
+    if (opts.body && opts.bodyFile) {
+        throw new CliError(ExitCode.Validation, 'ambiguous body input', 'pass only one of --body or --body-file');
+    }
+    if (opts.bodyFile) {
+        const fs = await import('node:fs/promises');
+        return (await fs.readFile(opts.bodyFile, 'utf8')).trim();
+    }
+    if (opts.body)
+        return opts.body;
+    if (opts.message)
+        return opts.message;
+    throw new CliError(ExitCode.Validation, 'missing --body or --body-file');
+}
+//# sourceMappingURL=channel.js.map