slack-term 1.18.0 → 1.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slack-term",
-  "version": "1.18.0",
+  "version": "1.19.1",
   "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),
     )

package/ts/format.ts

@@ -3,11 +3,13 @@
 import { listConversationMembers, listUsers, userInfo, userName, type Json } from "./slack.ts";
 
 /** Match an `@handle` token at a word boundary, capturing the handle.
- *  - The negative lookbehind keeps `@` inside emails (`a@b.com`) from matching.
+ *  - The negative lookbehind keeps `@` inside emails (`a@b.com`) from matching,
+ *    and the `<` keeps already-encoded mentions (`<@U0123>`) from being picked up
+ *    as a handle named after the user ID (Slack resolves those natively).
  *  - Each `.` must be followed by more handle chars, so a trailing sentence dot
  *    (`thanks @taku.`) is left out of the capture. */
 function mentionRe(): RegExp {
-  return /(?<![A-Za-z0-9._@-])@([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)/g;
+  return /(?<![A-Za-z0-9._@<-])@([A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*)/g;
 }
 
 /** Lowercase + strip hyphens/underscores/whitespace for loose handle matching. */

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 = "";