slack-term 1.17.0 → 1.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slack-term",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/snomiao/slack-term.git"

package/ts/cli.ts

@@ -17,6 +17,8 @@ import {
   authTest,
   authTestSession,
   conversationInfoSession,
+  createChannel,
+  inviteToChannel,
   createDraft,
   deleteDraft,
   updateDraft,
@@ -1128,6 +1130,56 @@ async function main(): Promise<void> {
             console.log(`private: ${ch.is_private === true}`);
           },
         )
+        .command(
+          ["create <name>", "new <name>"],
+          "Create a channel (confirm-hash safety gate)",
+          (y2) => y2
+            .positional("name", { type: "string", demandOption: true, describe: "Channel name (Slack lowercases it; no spaces)" })
+            .option("private", { type: "boolean", default: false, describe: "Create a private channel" })
+            .option("invite", { type: "string", array: true, default: [], describe: "Users to invite after creating (@handle or Uxxxx, repeatable)" })
+            .option("code", { type: "string", describe: "Safety hash to confirm create" }),
+          async (argv) => {
+            const token = tok(argv as W);
+            // Slack lowercases and strips the leading #; normalize for preview + code.
+            const name = argv.name!.replace(/^#/, "").toLowerCase();
+            const isPrivate = argv.private === true;
+            const invites = (argv.invite as string[]).filter(Boolean);
+            const code = safetyCode(name, String(isPrivate), invites.join(","));
+            if (argv.code !== code) requireCode(argv.code, code, [
+              `--- Creating channel -------------------------`,
+              `  name:    ${isPrivate ? "🔒 " : "#"}${name}`,
+              `  private: ${isPrivate}`,
+              ...(invites.length ? [`  invite:  ${invites.join(", ")}`] : []),
+              `--------------------------------────────────`,
+            ]);
+            let created: { id: string; name: string };
+            try {
+              created = await createChannel(token, name, isPrivate);
+            } catch (e: unknown) {
+              console.error(e instanceof Error ? e.message : String(e));
+              process.exit(1);
+            }
+            console.log(`✓ Created ${isPrivate ? "🔒 " : "#"}${created.name}  (${created.id})`);
+            if (invites.length) {
+              const ids: string[] = [];
+              for (const ref of invites) {
+                try {
+                  ids.push(ref.startsWith("U") || ref.startsWith("W") ? ref : await resolveUserId(token, ref));
+                } catch (e: unknown) {
+                  console.error(`  ! could not resolve ${ref}: ${e instanceof Error ? e.message : String(e)}`);
+                }
+              }
+              if (ids.length) {
+                try {
+                  await inviteToChannel(token, created.id, ids);
+                  console.log(`✓ Invited ${ids.length} member${ids.length === 1 ? "" : "s"}`);
+                } catch (e: unknown) {
+                  console.error(`  ! invite failed: ${e instanceof Error ? e.message : String(e)}`);
+                }
+              }
+            }
+          },
+        )
         .demandCommand(1, "")
         .showHelpOnFail(true),
     )
@@ -1264,14 +1316,17 @@ async function main(): Promise<void> {
         .option("user-id", { type: "string", describe: "Raw user ID (opens DM)" })
         .option("as-bot", { type: "boolean", default: false, describe: "Send via the bot token (xoxb / SLACK_BOT_TOKEN) so a DM notifies the recipient and can be two-way" })
         .option("broadcast", { type: "boolean", default: false, describe: "Also send to channel: broadcast a threaded reply back to the channel (Slack's \"Also send to #channel\" checkbox). Only effective with a thread target." })
-        .option("mentions", { type: "boolean", default: false, describe: "Convert @handle tokens in the message to real <@USERID> mentions (resolves via users.list, then channel members for Slack Connect guests; unresolved handles stay as plain text)" }),
+        .option("mentions", { type: "boolean", default: true, describe: "Convert @handle tokens to real <@USERID> mentions (on by default; resolves via users.list, then channel members for Slack Connect guests). Unresolved handles stay as plain text. The confirm preview shows the converted message before sending. Disable with --no-mentions for literal @text." }),
       async (argv) => {
         const args: SendArgs = { target: argv.target!, message: argv.message! };
         if (argv.code) args.code = argv.code;
         if (argv["channel-id"]) args.channelId = argv["channel-id"];
         if (argv["user-id"]) args.userId = argv["user-id"];
         if (argv.broadcast) args.broadcast = true;
-        if (argv.mentions) {
+        // Mentions on by default; `--no-mentions` (yargs negation) sets it false.
+        // A message with no `@token` short-circuits inside encodeMentions, so the
+        // common case pays no extra API call.
+        if (argv.mentions !== false) {
           args.mentions = true;
           // Resolve mentions with the user token (has users:read) even when the
           // message itself is sent via the bot token.
@@ -1394,12 +1449,12 @@ async function main(): Promise<void> {
         .positional("newText", { type: "string", demandOption: true })
         .option("code", { type: "string", describe: "Safety hash to confirm edit" })
         .option("channel-id", { type: "string", describe: "Raw channel ID" })
-        .option("mentions", { type: "boolean", default: false, describe: "Convert @handle tokens in the new text to real <@USERID> mentions (unresolved handles stay as plain text)" }),
+        .option("mentions", { type: "boolean", default: true, describe: "Convert @handle tokens in the new text to real <@USERID> mentions (on by default). Unresolved handles stay as plain text. Disable with --no-mentions for literal @text." }),
       async (argv) => {
         const args: EditArgs = { target: argv.target!, newText: argv.newText! };
         if (argv.code) args.code = argv.code;
         if (argv["channel-id"]) args.channelId = argv["channel-id"];
-        if (argv.mentions) args.mentions = true;
+        if (argv.mentions !== false) args.mentions = true;
         await cmdEdit(tok(argv as W), args);
       },
     )

package/ts/slack.ts

@@ -314,6 +314,31 @@ export async function deleteMessage(
   await post(token, "chat.delete", { channel, ts });
 }
 
+// Create a public (or private) channel via conversations.create. Slack
+// lowercases the name and rejects spaces/most punctuation; the raw API error
+// (e.g. name_taken, invalid_name_specials) surfaces to the caller. Returns the
+// new channel's { id, name }.
+export async function createChannel(
+  token: string,
+  name: string,
+  isPrivate = false,
+): Promise<{ id: string; name: string }> {
+  const resp = (await post(token, "conversations.create", {
+    name,
+    is_private: isPrivate,
+  })) as { channel?: { id?: string; name?: string } };
+  return { id: resp.channel?.id ?? "", name: resp.channel?.name ?? name };
+}
+
+// Invite users to a channel via conversations.invite (up to ~1000 ids).
+export async function inviteToChannel(
+  token: string,
+  channel: string,
+  userIds: string[],
+): Promise<void> {
+  await post(token, "conversations.invite", { channel, users: userIds.join(",") });
+}
+
 export async function listConversations(token: string): Promise<Json> {
   const allChannels: Json[] = [];
   let cursor = "";